﻿<!DOCTYPE html>
<!--[if IE]><![endif]-->
<html>
  
  <head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
    <title>Class DoubleTensor
   </title>
    <meta name="viewport" content="width=device-width">
    <meta name="title" content="Class DoubleTensor
   ">
    <meta name="generator" content="docfx 2.18.2.0">
    
    <link rel="shortcut icon" href="../../favicon.ico">
    <link rel="stylesheet" href="../../styles/docfx.vendor.css">
    <link rel="stylesheet" href="../../styles/docfx.css">
    <link rel="stylesheet" href="../../styles/main.css">
    <meta property="docfx:navrel" content="../../toc.html">
    <meta property="docfx:tocrel" content="../toc.html">
    
    
  </head>
  <body data-spy="scroll" data-target="#affix">
    <div id="wrapper">
      <header>
        
        <nav id="autocollapse" class="navbar navbar-inverse ng-scope" role="navigation">
          <div class="container">
            <div class="navbar-header">
              <button type="button" class="navbar-toggle" data-toggle="collapse" data-target="#navbar">
                <span class="sr-only">Toggle navigation</span>
                <span class="icon-bar"></span>
                <span class="icon-bar"></span>
                <span class="icon-bar"></span>
              </button>
              
              <a class="navbar-brand" href="../../index.html">
                <img id="logo" class="svg" src="../../logo.svg" alt="">
              </a>
            </div>
            <div class="collapse navbar-collapse" id="navbar">
              <form class="navbar-form navbar-right" role="search" id="search">
                <div class="form-group">
                  <input type="text" class="form-control" id="search-query" placeholder="Search" autocomplete="off">
                </div>
              </form>
            </div>
          </div>
        </nav>
        
        <div class="subnav navbar navbar-default">
          <div class="container hide-when-search" id="breadcrumb">
            <ul class="breadcrumb">
              <li></li>
            </ul>
          </div>
        </div>
      </header>
      <div role="main" class="container body-content hide-when-search">
        
        <div class="sidenav hide-when-search">
          <a class="btn toc-toggle collapse" data-toggle="collapse" href="#sidetoggle" aria-expanded="false" aria-controls="sidetoggle">Show / Hide Table of Contents</a>
          <div class="sidetoggle collapse" id="sidetoggle">
            <div id="sidetoc"></div>
          </div>
        </div>
        <div class="article row grid-right">
          <div class="col-md-10">
            <article class="content wrap" id="_content" data-uid="TorchSharp.DoubleTensor">
  
  
  <h1 id="TorchSharp_DoubleTensor" data-uid="TorchSharp.DoubleTensor">Class DoubleTensor
  </h1>
  <div class="markdown level0 summary"><p>Tensor of type Double.</p>
</div>
  <div class="markdown level0 conceptual"></div>
  <div class="inheritance">
    <h5>Inheritance</h5>
    <div class="level0"><span class="xref">System.Object</span></div>
    <div class="level1"><span class="xref">DoubleTensor</span></div>
  </div>
  <h6><strong>Namespace</strong>: <a class="xref" href="../TorchSharp.html">TorchSharp</a></h6>
  <h6><strong>Assembly</strong>: TorchSharp.dll</h6>
  <h5 id="TorchSharp_DoubleTensor_syntax">Syntax</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public class DoubleTensor : IDisposable</code></pre>
  </div>
  <h5 id="TorchSharp_DoubleTensor_remarks"><strong>Remarks</strong></h5>
  <div class="markdown level0 remarks"><p>
                Use the default constructor to create an empty tensor, or invoke one of the
                constructors with one (1D), two (2D), three (3D), or four parameters (4D) to x
                create a tensor for the desired number of dimensions.
              </p></div>
  <h3 id="constructors">Constructors
  </h3>
  
  
  <a id="TorchSharp_DoubleTensor__ctor_" data-uid="TorchSharp.DoubleTensor.#ctor*"></a>
  <h4 id="TorchSharp_DoubleTensor__ctor" data-uid="TorchSharp.DoubleTensor.#ctor">DoubleTensor()</h4>
  <div class="markdown level1 summary"><p>Creates an empty tensor.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public DoubleTensor ();</code></pre>
  </div>
  
  
  <a id="TorchSharp_DoubleTensor__ctor_" data-uid="TorchSharp.DoubleTensor.#ctor*"></a>
  <h4 id="TorchSharp_DoubleTensor__ctor_System_Int64_" data-uid="TorchSharp.DoubleTensor.#ctor(System.Int64)">DoubleTensor(Int64)</h4>
  <div class="markdown level1 summary"><p>Creates a 1D tensor of the specified size.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public DoubleTensor (long size0);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size0</span></td>
        <td><p>Size for the first dimension.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor__ctor_" data-uid="TorchSharp.DoubleTensor.#ctor*"></a>
  <h4 id="TorchSharp_DoubleTensor__ctor_System_Int64_System_Int64_" data-uid="TorchSharp.DoubleTensor.#ctor(System.Int64,System.Int64)">DoubleTensor(Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Creates a 2D tensor of the specified size.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public DoubleTensor (long size0, long size1);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size0</span></td>
        <td><p>Size for the first dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size1</span></td>
        <td><p>Size for the second dimension.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor__ctor_" data-uid="TorchSharp.DoubleTensor.#ctor*"></a>
  <h4 id="TorchSharp_DoubleTensor__ctor_System_Int64_System_Int64_System_Int64_" data-uid="TorchSharp.DoubleTensor.#ctor(System.Int64,System.Int64,System.Int64)">DoubleTensor(Int64, Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Creates a 3D tensor of the specified size.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public DoubleTensor (long size0, long size1, long size2);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size0</span></td>
        <td><p>Size for the first dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size1</span></td>
        <td><p>Size for the second dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size2</span></td>
        <td><p>Size for the third dimension.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor__ctor_" data-uid="TorchSharp.DoubleTensor.#ctor*"></a>
  <h4 id="TorchSharp_DoubleTensor__ctor_System_Int64_System_Int64_System_Int64_System_Int64_" data-uid="TorchSharp.DoubleTensor.#ctor(System.Int64,System.Int64,System.Int64,System.Int64)">DoubleTensor(Int64, Int64, Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Creates a 4D tensor of the specified size.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public DoubleTensor (long size0, long size1, long size2, long size3);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size0</span></td>
        <td><p>Size for the first dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size1</span></td>
        <td><p>Size for the second dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size2</span></td>
        <td><p>Size for the third dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size3</span></td>
        <td><p>Size for the fourth dimension.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h3 id="properties">Properties
  </h3>
  
  
  <a id="TorchSharp_DoubleTensor_Data_" data-uid="TorchSharp.DoubleTensor.Data*"></a>
  <h4 id="TorchSharp_DoubleTensor_Data" data-uid="TorchSharp.DoubleTensor.Data">Data</h4>
  <div class="markdown level1 summary"><p>Returns a pointer to the unmanaged data managed by this tensor.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public double* Data { get; }</code></pre>
  </div>
  <h5 class="propertyValue">Property Value</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span>*</td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Dimensions_" data-uid="TorchSharp.DoubleTensor.Dimensions*"></a>
  <h4 id="TorchSharp_DoubleTensor_Dimensions" data-uid="TorchSharp.DoubleTensor.Dimensions">Dimensions</h4>
  <div class="markdown level1 summary"><p>Returns the number of dimensions for this tensor</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public int Dimensions { get; }</code></pre>
  </div>
  <h5 class="propertyValue">Property Value</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Item_" data-uid="TorchSharp.DoubleTensor.Item*"></a>
  <h4 id="TorchSharp_DoubleTensor_Item_System_Int64_" data-uid="TorchSharp.DoubleTensor.Item(System.Int64)">Item(Int64)</h4>
  <div class="markdown level1 summary"><p>Access to element at the specified position in the tensor</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public double this[long x0] { get; set; }</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">x0</span></td>
        <td><p>Index to access.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="propertyValue">Property Value</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Item_" data-uid="TorchSharp.DoubleTensor.Item*"></a>
  <h4 id="TorchSharp_DoubleTensor_Item_System_Int64_System_Int64_" data-uid="TorchSharp.DoubleTensor.Item(System.Int64,System.Int64)">Item(Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Access to element at the specified position in the tensor</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public double this[long x0, long x1] { get; set; }</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">x0</span></td>
        <td><p>Index in the first dimension to access.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">x1</span></td>
        <td><p>Index in the second dimension to access.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="propertyValue">Property Value</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Item_" data-uid="TorchSharp.DoubleTensor.Item*"></a>
  <h4 id="TorchSharp_DoubleTensor_Item_System_Int64_System_Int64_System_Int64_" data-uid="TorchSharp.DoubleTensor.Item(System.Int64,System.Int64,System.Int64)">Item(Int64, Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Access to element at the specified position in the tensor</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public double this[long x0, long x1, long x2] { get; set; }</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">x0</span></td>
        <td><p>Index in the first dimension to access.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">x1</span></td>
        <td><p>Index in the second dimension to access.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">x2</span></td>
        <td><p>Index in the third dimension to access.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="propertyValue">Property Value</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Item_" data-uid="TorchSharp.DoubleTensor.Item*"></a>
  <h4 id="TorchSharp_DoubleTensor_Item_System_Int64_System_Int64_System_Int64_System_Int64_" data-uid="TorchSharp.DoubleTensor.Item(System.Int64,System.Int64,System.Int64,System.Int64)">Item(Int64, Int64, Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Access to element at the specified position in the tensor</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public double this[long x0, long x1, long x2, long x3] { get; set; }</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">x0</span></td>
        <td><p>Index in the first dimension to access.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">x1</span></td>
        <td><p>Index in the second dimension to access.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">x2</span></td>
        <td><p>Index in the third dimension to access.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">x3</span></td>
        <td><p>Index in the fourth dimension to access.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="propertyValue">Property Value</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Shape_" data-uid="TorchSharp.DoubleTensor.Shape*"></a>
  <h4 id="TorchSharp_DoubleTensor_Shape" data-uid="TorchSharp.DoubleTensor.Shape">Shape</h4>
  <div class="markdown level1 summary"><p>Returns the tensor shape, this is an array whose size determines the number of dimensions on the tensor, and each element is the size of the dimension</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public long[] Shape { get; }</code></pre>
  </div>
  <h5 class="propertyValue">Property Value</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span>[]</td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_DoubleTensor_Shape_remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>An array of size 0 is used for constants, an array of size 1 is used
                for single-dimension arrays, where the dimension is the value of the
                first element.   And so on.</p>
</div>
  
  
  <a id="TorchSharp_DoubleTensor_Storage_" data-uid="TorchSharp.DoubleTensor.Storage*"></a>
  <h4 id="TorchSharp_DoubleTensor_Storage" data-uid="TorchSharp.DoubleTensor.Storage">Storage</h4>
  <div class="markdown level1 summary"><p>Returns the associated storage for this tensor</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor.DoubleStorage Storage { get; }</code></pre>
  </div>
  <h5 class="propertyValue">Property Value</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h3 id="methods">Methods
  </h3>
  
  
  <a id="TorchSharp_DoubleTensor_Abs_" data-uid="TorchSharp.DoubleTensor.Abs*"></a>
  <h4 id="TorchSharp_DoubleTensor_Abs" data-uid="TorchSharp.DoubleTensor.Abs">Abs()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Abs of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Abs ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Abs_" data-uid="TorchSharp.DoubleTensor.Abs*"></a>
  <h4 id="TorchSharp_DoubleTensor_Abs_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Abs(TorchSharp.DoubleTensor)">Abs(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Abs of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Abs (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Acos_" data-uid="TorchSharp.DoubleTensor.Acos*"></a>
  <h4 id="TorchSharp_DoubleTensor_Acos" data-uid="TorchSharp.DoubleTensor.Acos">Acos()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Acos of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Acos ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Acos_" data-uid="TorchSharp.DoubleTensor.Acos*"></a>
  <h4 id="TorchSharp_DoubleTensor_Acos_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Acos(TorchSharp.DoubleTensor)">Acos(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Acos of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Acos (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Add_" data-uid="TorchSharp.DoubleTensor.Add*"></a>
  <h4 id="TorchSharp_DoubleTensor_Add_System_Double_" data-uid="TorchSharp.DoubleTensor.Add(System.Double)">Add(Double)</h4>
  <div class="markdown level1 summary"><p>Performs the Add operation on each element of the tensor with the
              <see paramref="value"></see> and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Add (double value);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_DoubleTensor_Add_System_Double__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>If you want to avoid the allocation of a new tensor, you can use the 
              alternative method <span class="xref">PytorchSharp.Add(PytorchSharp.DoubleTensor, Double, PytorchSharp.Double)</span>.</p>
</div>
  
  
  <a id="TorchSharp_DoubleTensor_Add_" data-uid="TorchSharp.DoubleTensor.Add*"></a>
  <h4 id="TorchSharp_DoubleTensor_Add_TorchSharp_DoubleTensor_System_Double_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Add(TorchSharp.DoubleTensor,System.Double,TorchSharp.DoubleTensor)">Add(DoubleTensor, Double, DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs the Add operation on each element of the source with the
              provided scalar.   The result tensor specified as the last parameters
              is resized to match the source.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public static void Add (TorchSharp.DoubleTensor source, double value, TorchSharp.DoubleTensor result);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>Source tensor on which the operation will take place.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>The scalar value that the operation uses.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">result</span></td>
        <td><p>The tensor where the result will be placed</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_DoubleTensor_Add_TorchSharp_DoubleTensor_System_Double_TorchSharp_DoubleTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>For each element in the <see paramref="source"></see> performs the Add operation
               with <see paramref="value"></see>.   The result is stored in the <see paramref="result"></see>
               tensor.</p>
</div>
  
  
  <a id="TorchSharp_DoubleTensor_AddBMM_" data-uid="TorchSharp.DoubleTensor.AddBMM*"></a>
  <h4 id="TorchSharp_DoubleTensor_AddBMM_System_Double_System_Double_TorchSharp_DoubleTensor_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.AddBMM(System.Double,System.Double,TorchSharp.DoubleTensor,TorchSharp.DoubleTensor)">AddBMM(Double, Double, DoubleTensor, DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs AddBMM of the tensor with the provided 
              <see paramref="src1"></see> and <see paramref="src1"></see> tensors and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor AddBMM (double beta, double alpha, TorchSharp.DoubleTensor batch1, TorchSharp.DoubleTensor batch2);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">beta</span></td>
        <td><p>Multiplier for this tensor (β).</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">alpha</span></td>
        <td><p>Multiplier for batch1xbatch2 (α)</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">batch1</span></td>
        <td><p>the first batch of matrices to be multiplied</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">batch2</span></td>
        <td><p>the second batch of matrices to be multiplied</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>β mat+α (∑i=0bbatch1i@batch2i)</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_DoubleTensor_AddBMM_System_Double_System_Double_TorchSharp_DoubleTensor_TorchSharp_DoubleTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>β mat+α (∑i=0bbatch1i@batch2i)</p>
</div>
  
  
  <a id="TorchSharp_DoubleTensor_AddCDiv_" data-uid="TorchSharp.DoubleTensor.AddCDiv*"></a>
  <h4 id="TorchSharp_DoubleTensor_AddCDiv_System_Double_TorchSharp_DoubleTensor_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.AddCDiv(System.Double,TorchSharp.DoubleTensor,TorchSharp.DoubleTensor)">AddCDiv(Double, DoubleTensor, DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs AddCDiv of the tensor with the provided 
              <see paramref="src1"></see> and <see paramref="src1"></see> tensors and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor AddCDiv (double value, TorchSharp.DoubleTensor src1, TorchSharp.DoubleTensor src2);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src1</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src2</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_AddCMul_" data-uid="TorchSharp.DoubleTensor.AddCMul*"></a>
  <h4 id="TorchSharp_DoubleTensor_AddCMul_System_Double_TorchSharp_DoubleTensor_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.AddCMul(System.Double,TorchSharp.DoubleTensor,TorchSharp.DoubleTensor)">AddCMul(Double, DoubleTensor, DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs AddCMul of the tensor with the provided 
              <see paramref="src1"></see> and <see paramref="src1"></see> tensors and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor AddCMul (double value, TorchSharp.DoubleTensor src1, TorchSharp.DoubleTensor src2);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src1</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src2</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_AddMM_" data-uid="TorchSharp.DoubleTensor.AddMM*"></a>
  <h4 id="TorchSharp_DoubleTensor_AddMM_System_Double_System_Double_TorchSharp_DoubleTensor_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.AddMM(System.Double,System.Double,TorchSharp.DoubleTensor,TorchSharp.DoubleTensor)">AddMM(Double, Double, DoubleTensor, DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs AddMM of the tensor with the provided 
              <see paramref="src1"></see> and <see paramref="src1"></see> tensors and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor AddMM (double beta, double alpha, TorchSharp.DoubleTensor mat1, TorchSharp.DoubleTensor mat2);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">beta</span></td>
        <td><p>Multiplier for this tensor (β).</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">alpha</span></td>
        <td><p>Multiplier for mat1xmat2 (α)</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">mat1</span></td>
        <td><p>First matrix to  be multiplied</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">mat2</span></td>
        <td><p>Second matrix to  be multiplied</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>β mat+α (mat1i@mat2i)</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_DoubleTensor_AddMM_System_Double_System_Double_TorchSharp_DoubleTensor_TorchSharp_DoubleTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>β mat+α (mat1i@mat2i)</p>
</div>
  
  
  <a id="TorchSharp_DoubleTensor_AddMV_" data-uid="TorchSharp.DoubleTensor.AddMV*"></a>
  <h4 id="TorchSharp_DoubleTensor_AddMV_System_Double_System_Double_TorchSharp_DoubleTensor_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.AddMV(System.Double,System.Double,TorchSharp.DoubleTensor,TorchSharp.DoubleTensor)">AddMV(Double, Double, DoubleTensor, DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs AddMV of the tensor with the provided 
              <see paramref="src1"></see> and <see paramref="src1"></see> tensors and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor AddMV (double beta, double alpha, TorchSharp.DoubleTensor mat, TorchSharp.DoubleTensor vec);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">beta</span></td>
        <td><p>Multiplier for this tensor (β).</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">alpha</span></td>
        <td><p>Multiplier for matxvec (α)</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">mat</span></td>
        <td><p>Matrix to be multiplied</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">vec</span></td>
        <td><p>Vector to be multiplied</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>β tensor+α (mat@vec)</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_DoubleTensor_AddMV_System_Double_System_Double_TorchSharp_DoubleTensor_TorchSharp_DoubleTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>β tensor+α (mat@vec)</p>
</div>
  
  
  <a id="TorchSharp_DoubleTensor_AddR_" data-uid="TorchSharp.DoubleTensor.AddR*"></a>
  <h4 id="TorchSharp_DoubleTensor_AddR_System_Double_System_Double_TorchSharp_DoubleTensor_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.AddR(System.Double,System.Double,TorchSharp.DoubleTensor,TorchSharp.DoubleTensor)">AddR(Double, Double, DoubleTensor, DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs AddR of the tensor with the provided 
              <see paramref="src1"></see> and <see paramref="src1"></see> tensors and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor AddR (double beta, double alpha, TorchSharp.DoubleTensor vec1, TorchSharp.DoubleTensor vec2);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">beta</span></td>
        <td><p>Multiplier for this tensor (β).</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">alpha</span></td>
        <td><p>Multiplier for vec1xvec2 (α)</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">vec1</span></td>
        <td><p>the first vector of the outer product</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">vec2</span></td>
        <td><p>the second vector of the outer product</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>β mat+α (vec1⊗vec2)</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_DoubleTensor_AddR_System_Double_System_Double_TorchSharp_DoubleTensor_TorchSharp_DoubleTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>β mat+α (vec1⊗vec2)</p>
</div>
  
  
  <a id="TorchSharp_DoubleTensor_AddScaled_" data-uid="TorchSharp.DoubleTensor.AddScaled*"></a>
  <h4 id="TorchSharp_DoubleTensor_AddScaled_System_Double_System_Double_" data-uid="TorchSharp.DoubleTensor.AddScaled(System.Double,System.Double)">AddScaled(Double, Double)</h4>
  <div class="markdown level1 summary"><p>Performs an AddScaled of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor AddScaled (double value1, double value2);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value1</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value2</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_ARange_" data-uid="TorchSharp.DoubleTensor.ARange*"></a>
  <h4 id="TorchSharp_DoubleTensor_ARange_System_Double_System_Double_System_Double_" data-uid="TorchSharp.DoubleTensor.ARange(System.Double,System.Double,System.Double)">ARange(Double, Double, Double)</h4>
  <div class="markdown level1 summary"><p>Create a range spanning from xmin to xmax, with &#39;step&#39; between each value.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public static TorchSharp.DoubleTensor ARange (double xmin, double xmax, double step);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">xmin</span></td>
        <td><p>The lower bound of the range.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">xmax</span></td>
        <td><p>The upper bound of the range.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">step</span></td>
        <td><p>The value step.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Asin_" data-uid="TorchSharp.DoubleTensor.Asin*"></a>
  <h4 id="TorchSharp_DoubleTensor_Asin" data-uid="TorchSharp.DoubleTensor.Asin">Asin()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Asin of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Asin ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Asin_" data-uid="TorchSharp.DoubleTensor.Asin*"></a>
  <h4 id="TorchSharp_DoubleTensor_Asin_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Asin(TorchSharp.DoubleTensor)">Asin(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Asin of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Asin (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Atan_" data-uid="TorchSharp.DoubleTensor.Atan*"></a>
  <h4 id="TorchSharp_DoubleTensor_Atan" data-uid="TorchSharp.DoubleTensor.Atan">Atan()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Atan of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Atan ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Atan_" data-uid="TorchSharp.DoubleTensor.Atan*"></a>
  <h4 id="TorchSharp_DoubleTensor_Atan_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Atan(TorchSharp.DoubleTensor)">Atan(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Atan of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Atan (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Atan2_" data-uid="TorchSharp.DoubleTensor.Atan2*"></a>
  <h4 id="TorchSharp_DoubleTensor_Atan2" data-uid="TorchSharp.DoubleTensor.Atan2">Atan2()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Atan2 of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Atan2 ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Atan2_" data-uid="TorchSharp.DoubleTensor.Atan2*"></a>
  <h4 id="TorchSharp_DoubleTensor_Atan2_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Atan2(TorchSharp.DoubleTensor)">Atan2(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Atan2 of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Atan2 (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_BAddBMM_" data-uid="TorchSharp.DoubleTensor.BAddBMM*"></a>
  <h4 id="TorchSharp_DoubleTensor_BAddBMM_System_Double_System_Double_TorchSharp_DoubleTensor_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.BAddBMM(System.Double,System.Double,TorchSharp.DoubleTensor,TorchSharp.DoubleTensor)">BAddBMM(Double, Double, DoubleTensor, DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs BAddBMM of the tensor with the provided 
              <see paramref="src1"></see> and <see paramref="src1"></see> tensors and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor BAddBMM (double beta, double alpha, TorchSharp.DoubleTensor batch1, TorchSharp.DoubleTensor batch2);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">beta</span></td>
        <td><p>Multiplier for this tensor (β).</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">alpha</span></td>
        <td><p>Multiplier for batch1xbatch2 (α)</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">batch1</span></td>
        <td><p>the first batch of matrices to be multiplied</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">batch2</span></td>
        <td><p>the second batch of matrices to be multiplied</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>β mati+α (batch1i@batch2i)</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_DoubleTensor_BAddBMM_System_Double_System_Double_TorchSharp_DoubleTensor_TorchSharp_DoubleTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>β mati+α (batch1i@batch2i)</p>
</div>
  
  
  <a id="TorchSharp_DoubleTensor_BHistc_" data-uid="TorchSharp.DoubleTensor.BHistc*"></a>
  <h4 id="TorchSharp_DoubleTensor_BHistc_System_Int64_System_Double_System_Double_" data-uid="TorchSharp.DoubleTensor.BHistc(System.Int64,System.Double,System.Double)">BHistc(Int64, Double, Double)</h4>
  <div class="markdown level1 summary"><p>Create a histogram of all tensor elements.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor BHistc (long nbins, double minvalue, double maxvalue);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">nbins</span></td>
        <td><p>The number of bins in the output histogram.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">minvalue</span></td>
        <td><p>Only consider values equal to or greater than this.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">maxvalue</span></td>
        <td><p>Only consider values equal to or less than this.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_BitAnd_" data-uid="TorchSharp.DoubleTensor.BitAnd*"></a>
  <h4 id="TorchSharp_DoubleTensor_BitAnd_System_Double_" data-uid="TorchSharp.DoubleTensor.BitAnd(System.Double)">BitAnd(Double)</h4>
  <div class="markdown level1 summary"><p>Performs the BitAnd operation on each element of the tensor with the
              <see paramref="value"></see> and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor BitAnd (double value);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_DoubleTensor_BitAnd_System_Double__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>If you want to avoid the allocation of a new tensor, you can use the 
              alternative method <span class="xref">PytorchSharp.BitAnd(PytorchSharp.DoubleTensor, Double, PytorchSharp.Double)</span>.</p>
</div>
  
  
  <a id="TorchSharp_DoubleTensor_BitAnd_" data-uid="TorchSharp.DoubleTensor.BitAnd*"></a>
  <h4 id="TorchSharp_DoubleTensor_BitAnd_TorchSharp_DoubleTensor_System_Double_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.BitAnd(TorchSharp.DoubleTensor,System.Double,TorchSharp.DoubleTensor)">BitAnd(DoubleTensor, Double, DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs the BitAnd operation on each element of the source with the
              provided scalar.   The result tensor specified as the last parameters
              is resized to match the source.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public static void BitAnd (TorchSharp.DoubleTensor source, double value, TorchSharp.DoubleTensor result);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>Source tensor on which the operation will take place.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>The scalar value that the operation uses.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">result</span></td>
        <td><p>The tensor where the result will be placed</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_DoubleTensor_BitAnd_TorchSharp_DoubleTensor_System_Double_TorchSharp_DoubleTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>For each element in the <see paramref="source"></see> performs the BitAnd operation
               with <see paramref="value"></see>.   The result is stored in the <see paramref="result"></see>
               tensor.</p>
</div>
  
  
  <a id="TorchSharp_DoubleTensor_CAdd_" data-uid="TorchSharp.DoubleTensor.CAdd*"></a>
  <h4 id="TorchSharp_DoubleTensor_CAdd_System_Double_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.CAdd(System.Double,TorchSharp.DoubleTensor)">CAdd(Double, DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs the CAdd operation on each element of the tensor with the
              <see paramref="value"></see> and returns a new tensor with the result.
              where the result is t[idx] + value * src[idx]</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor CAdd (double value, TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_CappedRandom_" data-uid="TorchSharp.DoubleTensor.CappedRandom*"></a>
  <h4 id="TorchSharp_DoubleTensor_CappedRandom_TorchSharp_RandomGenerator_System_Int64_" data-uid="TorchSharp.DoubleTensor.CappedRandom(TorchSharp.RandomGenerator,System.Int64)">CappedRandom(RandomGenerator, Int64)</h4>
  <div class="markdown level1 summary"><p>Populates the tensor with random values from 0 to max, using the provided random source generator.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void CappedRandom (TorchSharp.RandomGenerator source, long max);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.RandomGenerator.html">RandomGenerator</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>The random generator source</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">max</span></td>
        <td><p>The upper limit for the values to be generated</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Cauchy_" data-uid="TorchSharp.DoubleTensor.Cauchy*"></a>
  <h4 id="TorchSharp_DoubleTensor_Cauchy_TorchSharp_RandomGenerator_System_Double_System_Double_" data-uid="TorchSharp.DoubleTensor.Cauchy(TorchSharp.RandomGenerator,System.Double,System.Double)">Cauchy(RandomGenerator, Double, Double)</h4>
  <div class="markdown level1 summary"><p>Fills the tensor with values according to a Cauchy-Lorentz distribution.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Cauchy (TorchSharp.RandomGenerator source, double median, double sigma);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.RandomGenerator.html">RandomGenerator</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>The random generator source</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">median</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">sigma</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_CBitAnd_" data-uid="TorchSharp.DoubleTensor.CBitAnd*"></a>
  <h4 id="TorchSharp_DoubleTensor_CBitAnd_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.CBitAnd(TorchSharp.DoubleTensor)">CBitAnd(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an CBitAnd of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor CBitAnd (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_CBitOr_" data-uid="TorchSharp.DoubleTensor.CBitOr*"></a>
  <h4 id="TorchSharp_DoubleTensor_CBitOr_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.CBitOr(TorchSharp.DoubleTensor)">CBitOr(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an CBitOr of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor CBitOr (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_CBitXor_" data-uid="TorchSharp.DoubleTensor.CBitXor*"></a>
  <h4 id="TorchSharp_DoubleTensor_CBitXor_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.CBitXor(TorchSharp.DoubleTensor)">CBitXor(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an CBitXor of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor CBitXor (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_CDiv_" data-uid="TorchSharp.DoubleTensor.CDiv*"></a>
  <h4 id="TorchSharp_DoubleTensor_CDiv_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.CDiv(TorchSharp.DoubleTensor)">CDiv(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an CDiv of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor CDiv (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Ceil_" data-uid="TorchSharp.DoubleTensor.Ceil*"></a>
  <h4 id="TorchSharp_DoubleTensor_Ceil" data-uid="TorchSharp.DoubleTensor.Ceil">Ceil()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Ceil of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Ceil ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Ceil_" data-uid="TorchSharp.DoubleTensor.Ceil*"></a>
  <h4 id="TorchSharp_DoubleTensor_Ceil_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Ceil(TorchSharp.DoubleTensor)">Ceil(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Ceil of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Ceil (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_CFMod_" data-uid="TorchSharp.DoubleTensor.CFMod*"></a>
  <h4 id="TorchSharp_DoubleTensor_CFMod_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.CFMod(TorchSharp.DoubleTensor)">CFMod(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an CFMod of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor CFMod (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_cinv_" data-uid="TorchSharp.DoubleTensor.cinv*"></a>
  <h4 id="TorchSharp_DoubleTensor_cinv" data-uid="TorchSharp.DoubleTensor.cinv">cinv()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the cinv of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor cinv ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_cinv_" data-uid="TorchSharp.DoubleTensor.cinv*"></a>
  <h4 id="TorchSharp_DoubleTensor_cinv_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.cinv(TorchSharp.DoubleTensor)">cinv(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the cinv of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor cinv (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Clamp_" data-uid="TorchSharp.DoubleTensor.Clamp*"></a>
  <h4 id="TorchSharp_DoubleTensor_Clamp_System_Double_" data-uid="TorchSharp.DoubleTensor.Clamp(System.Double)">Clamp(Double)</h4>
  <div class="markdown level1 summary"><p>Performs the Clamp operation on each element of the tensor with the
              <see paramref="value"></see> and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Clamp (double value);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_DoubleTensor_Clamp_System_Double__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>If you want to avoid the allocation of a new tensor, you can use the 
              alternative method <span class="xref">PytorchSharp.Clamp(PytorchSharp.DoubleTensor, Double, PytorchSharp.Double)</span>.</p>
</div>
  
  
  <a id="TorchSharp_DoubleTensor_Clamp_" data-uid="TorchSharp.DoubleTensor.Clamp*"></a>
  <h4 id="TorchSharp_DoubleTensor_Clamp_System_Double_System_Double_" data-uid="TorchSharp.DoubleTensor.Clamp(System.Double,System.Double)">Clamp(Double, Double)</h4>
  <div class="markdown level1 summary"><p>Performs an Clamp of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Clamp (double value1, double value2);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value1</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value2</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Clamp_" data-uid="TorchSharp.DoubleTensor.Clamp*"></a>
  <h4 id="TorchSharp_DoubleTensor_Clamp_TorchSharp_DoubleTensor_System_Double_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Clamp(TorchSharp.DoubleTensor,System.Double,TorchSharp.DoubleTensor)">Clamp(DoubleTensor, Double, DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs the Clamp operation on each element of the source with the
              provided scalar.   The result tensor specified as the last parameters
              is resized to match the source.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public static void Clamp (TorchSharp.DoubleTensor source, double value, TorchSharp.DoubleTensor result);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>Source tensor on which the operation will take place.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>The scalar value that the operation uses.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">result</span></td>
        <td><p>The tensor where the result will be placed</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_DoubleTensor_Clamp_TorchSharp_DoubleTensor_System_Double_TorchSharp_DoubleTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>For each element in the <see paramref="source"></see> performs the Clamp operation
               with <see paramref="value"></see>.   The result is stored in the <see paramref="result"></see>
               tensor.</p>
</div>
  
  
  <a id="TorchSharp_DoubleTensor_ClampedRandom_" data-uid="TorchSharp.DoubleTensor.ClampedRandom*"></a>
  <h4 id="TorchSharp_DoubleTensor_ClampedRandom_TorchSharp_RandomGenerator_System_Int64_System_Int64_" data-uid="TorchSharp.DoubleTensor.ClampedRandom(TorchSharp.RandomGenerator,System.Int64,System.Int64)">ClampedRandom(RandomGenerator, Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Populates the tensor with random values from min to max, using the provided random source generator.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void ClampedRandom (TorchSharp.RandomGenerator source, long min, long max);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.RandomGenerator.html">RandomGenerator</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>The random generator source</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">min</span></td>
        <td><p>The lower limit for the values to be generated</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">max</span></td>
        <td><p>The upper limit for the values to be generated</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Clone_" data-uid="TorchSharp.DoubleTensor.Clone*"></a>
  <h4 id="TorchSharp_DoubleTensor_Clone" data-uid="TorchSharp.DoubleTensor.Clone">Clone()</h4>
  <div class="markdown level1 summary"><p>Returns a deep clone of the tensor</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Clone ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_CLShift_" data-uid="TorchSharp.DoubleTensor.CLShift*"></a>
  <h4 id="TorchSharp_DoubleTensor_CLShift_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.CLShift(TorchSharp.DoubleTensor)">CLShift(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an CLShift of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor CLShift (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_CMax_" data-uid="TorchSharp.DoubleTensor.CMax*"></a>
  <h4 id="TorchSharp_DoubleTensor_CMax_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.CMax(TorchSharp.DoubleTensor)">CMax(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an CMax of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor CMax (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_CMaxValue_" data-uid="TorchSharp.DoubleTensor.CMaxValue*"></a>
  <h4 id="TorchSharp_DoubleTensor_CMaxValue_System_Double_" data-uid="TorchSharp.DoubleTensor.CMaxValue(System.Double)">CMaxValue(Double)</h4>
  <div class="markdown level1 summary"><p>Performs an CMaxValue of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor CMaxValue (double src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_CMin_" data-uid="TorchSharp.DoubleTensor.CMin*"></a>
  <h4 id="TorchSharp_DoubleTensor_CMin_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.CMin(TorchSharp.DoubleTensor)">CMin(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an CMin of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor CMin (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_CMinValue_" data-uid="TorchSharp.DoubleTensor.CMinValue*"></a>
  <h4 id="TorchSharp_DoubleTensor_CMinValue_System_Double_" data-uid="TorchSharp.DoubleTensor.CMinValue(System.Double)">CMinValue(Double)</h4>
  <div class="markdown level1 summary"><p>Performs an CMinValue of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor CMinValue (double src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_CMul_" data-uid="TorchSharp.DoubleTensor.CMul*"></a>
  <h4 id="TorchSharp_DoubleTensor_CMul_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.CMul(TorchSharp.DoubleTensor)">CMul(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an CMul of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor CMul (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Concatenate_" data-uid="TorchSharp.DoubleTensor.Concatenate*"></a>
  <h4 id="TorchSharp_DoubleTensor_Concatenate_TorchSharp_DoubleTensor_System_Int32_" data-uid="TorchSharp.DoubleTensor.Concatenate(TorchSharp.DoubleTensor,System.Int32)">Concatenate(DoubleTensor, Int32)</h4>
  <div class="markdown level1 summary"><p>Concatenate tensors along the given dimesion.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Concatenate (TorchSharp.DoubleTensor other, int dimension);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">other</span></td>
        <td><p>The second tensor.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension along which to concatenate.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Copy_" data-uid="TorchSharp.DoubleTensor.Copy*"></a>
  <h4 id="TorchSharp_DoubleTensor_Copy_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Copy(TorchSharp.DoubleTensor)">Copy(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Copies the elements of a tensor into the original tensor. 
              The shape of the tensors must exactly match or an error will be thrown.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Copy (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>Tensor to copy the data from.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_CopyByte_" data-uid="TorchSharp.DoubleTensor.CopyByte*"></a>
  <h4 id="TorchSharp_DoubleTensor_CopyByte_TorchSharp_ByteTensor_" data-uid="TorchSharp.DoubleTensor.CopyByte(TorchSharp.ByteTensor)">CopyByte(ByteTensor)</h4>
  <div class="markdown level1 summary"><p>Copies the elements of a byte tensor into the original tensor. 
              The shape of the tensors must exactly match or an error will be thrown.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void CopyByte (TorchSharp.ByteTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ByteTensor.html">ByteTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>Tensor to copy the data from.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_CopyDouble_" data-uid="TorchSharp.DoubleTensor.CopyDouble*"></a>
  <h4 id="TorchSharp_DoubleTensor_CopyDouble_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.CopyDouble(TorchSharp.DoubleTensor)">CopyDouble(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Copies the elements of a double tensor into the original tensor. 
              The shape of the tensors must exactly match or an error will be thrown.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void CopyDouble (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>Tensor to copy the data from.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_CopyFloat_" data-uid="TorchSharp.DoubleTensor.CopyFloat*"></a>
  <h4 id="TorchSharp_DoubleTensor_CopyFloat_TorchSharp_FloatTensor_" data-uid="TorchSharp.DoubleTensor.CopyFloat(TorchSharp.FloatTensor)">CopyFloat(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Copies the elements of a float tensor into the original tensor. 
              The shape of the tensors must exactly match or an error will be thrown.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void CopyFloat (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>Tensor to copy the data from.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_CopyInt_" data-uid="TorchSharp.DoubleTensor.CopyInt*"></a>
  <h4 id="TorchSharp_DoubleTensor_CopyInt_TorchSharp_IntTensor_" data-uid="TorchSharp.DoubleTensor.CopyInt(TorchSharp.IntTensor)">CopyInt(IntTensor)</h4>
  <div class="markdown level1 summary"><p>Copies the elements of a int tensor into the original tensor. 
              The shape of the tensors must exactly match or an error will be thrown.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void CopyInt (TorchSharp.IntTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.IntTensor.html">IntTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>Tensor to copy the data from.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_CopyLong_" data-uid="TorchSharp.DoubleTensor.CopyLong*"></a>
  <h4 id="TorchSharp_DoubleTensor_CopyLong_TorchSharp_LongTensor_" data-uid="TorchSharp.DoubleTensor.CopyLong(TorchSharp.LongTensor)">CopyLong(LongTensor)</h4>
  <div class="markdown level1 summary"><p>Copies the elements of a long tensor into the original tensor. 
              The shape of the tensors must exactly match or an error will be thrown.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void CopyLong (TorchSharp.LongTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>Tensor to copy the data from.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_CopyShort_" data-uid="TorchSharp.DoubleTensor.CopyShort*"></a>
  <h4 id="TorchSharp_DoubleTensor_CopyShort_TorchSharp_ShortTensor_" data-uid="TorchSharp.DoubleTensor.CopyShort(TorchSharp.ShortTensor)">CopyShort(ShortTensor)</h4>
  <div class="markdown level1 summary"><p>Copies the elements of a short tensor into the original tensor. 
              The shape of the tensors must exactly match or an error will be thrown.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void CopyShort (TorchSharp.ShortTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ShortTensor.html">ShortTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>Tensor to copy the data from.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Cos_" data-uid="TorchSharp.DoubleTensor.Cos*"></a>
  <h4 id="TorchSharp_DoubleTensor_Cos" data-uid="TorchSharp.DoubleTensor.Cos">Cos()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Cos of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Cos ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Cos_" data-uid="TorchSharp.DoubleTensor.Cos*"></a>
  <h4 id="TorchSharp_DoubleTensor_Cos_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Cos(TorchSharp.DoubleTensor)">Cos(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Cos of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Cos (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Cosh_" data-uid="TorchSharp.DoubleTensor.Cosh*"></a>
  <h4 id="TorchSharp_DoubleTensor_Cosh" data-uid="TorchSharp.DoubleTensor.Cosh">Cosh()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Cosh of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Cosh ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Cosh_" data-uid="TorchSharp.DoubleTensor.Cosh*"></a>
  <h4 id="TorchSharp_DoubleTensor_Cosh_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Cosh(TorchSharp.DoubleTensor)">Cosh(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Cosh of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Cosh (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_CPow_" data-uid="TorchSharp.DoubleTensor.CPow*"></a>
  <h4 id="TorchSharp_DoubleTensor_CPow_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.CPow(TorchSharp.DoubleTensor)">CPow(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an CPow of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor CPow (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_CRemainder_" data-uid="TorchSharp.DoubleTensor.CRemainder*"></a>
  <h4 id="TorchSharp_DoubleTensor_CRemainder_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.CRemainder(TorchSharp.DoubleTensor)">CRemainder(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an CRemainder of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor CRemainder (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_CrossProduct_" data-uid="TorchSharp.DoubleTensor.CrossProduct*"></a>
  <h4 id="TorchSharp_DoubleTensor_CrossProduct_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.CrossProduct(TorchSharp.DoubleTensor)">CrossProduct(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Computes the cross product of two tensors.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor CrossProduct (TorchSharp.DoubleTensor other);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">other</span></td>
        <td><p>The right-hand-side tensor.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_CSub_" data-uid="TorchSharp.DoubleTensor.CSub*"></a>
  <h4 id="TorchSharp_DoubleTensor_CSub_System_Double_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.CSub(System.Double,TorchSharp.DoubleTensor)">CSub(Double, DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs the CSub operation on each element of the tensor with the
              <see paramref="value"></see> and returns a new tensor with the result.
              where the result is t[idx] + value * src[idx]</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor CSub (double value, TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_CumulativeProd_" data-uid="TorchSharp.DoubleTensor.CumulativeProd*"></a>
  <h4 id="TorchSharp_DoubleTensor_CumulativeProd_System_Int32_" data-uid="TorchSharp.DoubleTensor.CumulativeProd(System.Int32)">CumulativeProd(Int32)</h4>
  <div class="markdown level1 summary"><p>Computes the cumulative product of all the elements of the tensor along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor CumulativeProd (int dimension);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to process along.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_CumulativeSum_" data-uid="TorchSharp.DoubleTensor.CumulativeSum*"></a>
  <h4 id="TorchSharp_DoubleTensor_CumulativeSum_System_Int32_" data-uid="TorchSharp.DoubleTensor.CumulativeSum(System.Int32)">CumulativeSum(Int32)</h4>
  <div class="markdown level1 summary"><p>Computes the cumulative sum of all the elements of the tensor along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor CumulativeSum (int dimension);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to process along.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Diagonal_" data-uid="TorchSharp.DoubleTensor.Diagonal*"></a>
  <h4 id="TorchSharp_DoubleTensor_Diagonal_System_Int32_" data-uid="TorchSharp.DoubleTensor.Diagonal(System.Int32)">Diagonal(Int32)</h4>
  <div class="markdown level1 summary"><p>Gets the diagonal of the tensor.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Diagonal (int k);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">k</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Digamma_" data-uid="TorchSharp.DoubleTensor.Digamma*"></a>
  <h4 id="TorchSharp_DoubleTensor_Digamma" data-uid="TorchSharp.DoubleTensor.Digamma">Digamma()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Digamma of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Digamma ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Digamma_" data-uid="TorchSharp.DoubleTensor.Digamma*"></a>
  <h4 id="TorchSharp_DoubleTensor_Digamma_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Digamma(TorchSharp.DoubleTensor)">Digamma(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Digamma of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Digamma (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_DirichletGrad_" data-uid="TorchSharp.DoubleTensor.DirichletGrad*"></a>
  <h4 id="TorchSharp_DoubleTensor_DirichletGrad_TorchSharp_DoubleTensor_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.DirichletGrad(TorchSharp.DoubleTensor,TorchSharp.DoubleTensor)">DirichletGrad(DoubleTensor, DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>DirichletGrad</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor DirichletGrad (TorchSharp.DoubleTensor alpha, TorchSharp.DoubleTensor total);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">alpha</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">total</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Dispose_" data-uid="TorchSharp.DoubleTensor.Dispose*"></a>
  <h4 id="TorchSharp_DoubleTensor_Dispose" data-uid="TorchSharp.DoubleTensor.Dispose">Dispose()</h4>
  <div class="markdown level1 summary"><p>Releases the tensor and its associated data.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Dispose ();</code></pre>
  </div>
  
  
  <a id="TorchSharp_DoubleTensor_Dispose_" data-uid="TorchSharp.DoubleTensor.Dispose*"></a>
  <h4 id="TorchSharp_DoubleTensor_Dispose_System_Boolean_" data-uid="TorchSharp.DoubleTensor.Dispose(System.Boolean)">Dispose(Boolean)</h4>
  <div class="markdown level1 summary"><p>Implements the .NET Dispose pattern.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">protected void Dispose (bool disposing);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">disposing</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Dist_" data-uid="TorchSharp.DoubleTensor.Dist*"></a>
  <h4 id="TorchSharp_DoubleTensor_Dist_TorchSharp_DoubleTensor_System_Double_" data-uid="TorchSharp.DoubleTensor.Dist(TorchSharp.DoubleTensor,System.Double)">Dist(DoubleTensor, Double)</h4>
  <div class="markdown level1 summary"><p>Compute the dist of all tensor elements along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public double Dist (TorchSharp.DoubleTensor other, double value);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">other</span></td>
        <td><p>The other tensor.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Div_" data-uid="TorchSharp.DoubleTensor.Div*"></a>
  <h4 id="TorchSharp_DoubleTensor_Div_System_Double_" data-uid="TorchSharp.DoubleTensor.Div(System.Double)">Div(Double)</h4>
  <div class="markdown level1 summary"><p>Performs the Div operation on each element of the tensor with the
              <see paramref="value"></see> and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Div (double value);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_DoubleTensor_Div_System_Double__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>If you want to avoid the allocation of a new tensor, you can use the 
              alternative method <span class="xref">PytorchSharp.Div(PytorchSharp.DoubleTensor, Double, PytorchSharp.Double)</span>.</p>
</div>
  
  
  <a id="TorchSharp_DoubleTensor_Div_" data-uid="TorchSharp.DoubleTensor.Div*"></a>
  <h4 id="TorchSharp_DoubleTensor_Div_TorchSharp_DoubleTensor_System_Double_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Div(TorchSharp.DoubleTensor,System.Double,TorchSharp.DoubleTensor)">Div(DoubleTensor, Double, DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs the Div operation on each element of the source with the
              provided scalar.   The result tensor specified as the last parameters
              is resized to match the source.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public static void Div (TorchSharp.DoubleTensor source, double value, TorchSharp.DoubleTensor result);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>Source tensor on which the operation will take place.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>The scalar value that the operation uses.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">result</span></td>
        <td><p>The tensor where the result will be placed</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_DoubleTensor_Div_TorchSharp_DoubleTensor_System_Double_TorchSharp_DoubleTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>For each element in the <see paramref="source"></see> performs the Div operation
               with <see paramref="value"></see>.   The result is stored in the <see paramref="result"></see>
               tensor.</p>
</div>
  
  
  <a id="TorchSharp_DoubleTensor_Dot_" data-uid="TorchSharp.DoubleTensor.Dot*"></a>
  <h4 id="TorchSharp_DoubleTensor_Dot_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Dot(TorchSharp.DoubleTensor)">Dot(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns the tensor product between this tensor and the provided one</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public double Dot (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><p>The dot product</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_EqTensor_" data-uid="TorchSharp.DoubleTensor.EqTensor*"></a>
  <h4 id="TorchSharp_DoubleTensor_EqTensor_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.EqTensor(TorchSharp.DoubleTensor)">EqTensor(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an EqTensor of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.ByteTensor EqTensor (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ByteTensor.html">ByteTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_EqTensorT_" data-uid="TorchSharp.DoubleTensor.EqTensorT*"></a>
  <h4 id="TorchSharp_DoubleTensor_EqTensorT_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.EqTensorT(TorchSharp.DoubleTensor)">EqTensorT(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an EqTensorT of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor EqTensorT (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Equal_" data-uid="TorchSharp.DoubleTensor.Equal*"></a>
  <h4 id="TorchSharp_DoubleTensor_Equal_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Equal(TorchSharp.DoubleTensor)">Equal(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Compare the tensor with another for complete equality.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public bool Equal (TorchSharp.DoubleTensor other);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">other</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_EqValue_" data-uid="TorchSharp.DoubleTensor.EqValue*"></a>
  <h4 id="TorchSharp_DoubleTensor_EqValue_System_Double_" data-uid="TorchSharp.DoubleTensor.EqValue(System.Double)">EqValue(Double)</h4>
  <div class="markdown level1 summary"><p>Performs an EqValue of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.ByteTensor EqValue (double src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ByteTensor.html">ByteTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_EqValueT_" data-uid="TorchSharp.DoubleTensor.EqValueT*"></a>
  <h4 id="TorchSharp_DoubleTensor_EqValueT_System_Double_" data-uid="TorchSharp.DoubleTensor.EqValueT(System.Double)">EqValueT(Double)</h4>
  <div class="markdown level1 summary"><p>Performs an EqValueT of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor EqValueT (double src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Erf_" data-uid="TorchSharp.DoubleTensor.Erf*"></a>
  <h4 id="TorchSharp_DoubleTensor_Erf" data-uid="TorchSharp.DoubleTensor.Erf">Erf()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Erf of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Erf ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Erf_" data-uid="TorchSharp.DoubleTensor.Erf*"></a>
  <h4 id="TorchSharp_DoubleTensor_Erf_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Erf(TorchSharp.DoubleTensor)">Erf(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Erf of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Erf (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Erfc_" data-uid="TorchSharp.DoubleTensor.Erfc*"></a>
  <h4 id="TorchSharp_DoubleTensor_Erfc" data-uid="TorchSharp.DoubleTensor.Erfc">Erfc()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Erfc of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Erfc ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Erfc_" data-uid="TorchSharp.DoubleTensor.Erfc*"></a>
  <h4 id="TorchSharp_DoubleTensor_Erfc_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Erfc(TorchSharp.DoubleTensor)">Erfc(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Erfc of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Erfc (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Erfinv_" data-uid="TorchSharp.DoubleTensor.Erfinv*"></a>
  <h4 id="TorchSharp_DoubleTensor_Erfinv" data-uid="TorchSharp.DoubleTensor.Erfinv">Erfinv()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Erfinv of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Erfinv ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Erfinv_" data-uid="TorchSharp.DoubleTensor.Erfinv*"></a>
  <h4 id="TorchSharp_DoubleTensor_Erfinv_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Erfinv(TorchSharp.DoubleTensor)">Erfinv(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Erfinv of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Erfinv (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Exp_" data-uid="TorchSharp.DoubleTensor.Exp*"></a>
  <h4 id="TorchSharp_DoubleTensor_Exp" data-uid="TorchSharp.DoubleTensor.Exp">Exp()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Exp of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Exp ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Exp_" data-uid="TorchSharp.DoubleTensor.Exp*"></a>
  <h4 id="TorchSharp_DoubleTensor_Exp_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Exp(TorchSharp.DoubleTensor)">Exp(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Exp of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Exp (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Expm1_" data-uid="TorchSharp.DoubleTensor.Expm1*"></a>
  <h4 id="TorchSharp_DoubleTensor_Expm1" data-uid="TorchSharp.DoubleTensor.Expm1">Expm1()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Expm1 of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Expm1 ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Expm1_" data-uid="TorchSharp.DoubleTensor.Expm1*"></a>
  <h4 id="TorchSharp_DoubleTensor_Expm1_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Expm1(TorchSharp.DoubleTensor)">Expm1(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Expm1 of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Expm1 (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Exponential_" data-uid="TorchSharp.DoubleTensor.Exponential*"></a>
  <h4 id="TorchSharp_DoubleTensor_Exponential_TorchSharp_RandomGenerator_System_Double_" data-uid="TorchSharp.DoubleTensor.Exponential(TorchSharp.RandomGenerator,System.Double)">Exponential(RandomGenerator, Double)</h4>
  <div class="markdown level1 summary"><p>Fills the tensor with values according to a exponential distribution.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Exponential (TorchSharp.RandomGenerator source, double lambda);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.RandomGenerator.html">RandomGenerator</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>The random generator source</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">lambda</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Eye_" data-uid="TorchSharp.DoubleTensor.Eye*"></a>
  <h4 id="TorchSharp_DoubleTensor_Eye_System_Int64_System_Int64_" data-uid="TorchSharp.DoubleTensor.Eye(System.Int64,System.Int64)">Eye(Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Eye.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public static TorchSharp.DoubleTensor Eye (long m, long n);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">m</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">n</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Fill_" data-uid="TorchSharp.DoubleTensor.Fill*"></a>
  <h4 id="TorchSharp_DoubleTensor_Fill_System_Double_" data-uid="TorchSharp.DoubleTensor.Fill(System.Double)">Fill(Double)</h4>
  <div class="markdown level1 summary"><p>Fills the tensor with the specified value</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Fill (double value);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Finalize_" data-uid="TorchSharp.DoubleTensor.Finalize*"></a>
  <h4 id="TorchSharp_DoubleTensor_Finalize" data-uid="TorchSharp.DoubleTensor.Finalize">Finalize()</h4>
  <div class="markdown level1 summary"><p>Finalizer for ~DoubleTensor</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">~DoubleTensor ();</code></pre>
  </div>
  
  
  <a id="TorchSharp_DoubleTensor_Floor_" data-uid="TorchSharp.DoubleTensor.Floor*"></a>
  <h4 id="TorchSharp_DoubleTensor_Floor" data-uid="TorchSharp.DoubleTensor.Floor">Floor()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Floor of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Floor ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Floor_" data-uid="TorchSharp.DoubleTensor.Floor*"></a>
  <h4 id="TorchSharp_DoubleTensor_Floor_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Floor(TorchSharp.DoubleTensor)">Floor(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Floor of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Floor (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Fmod_" data-uid="TorchSharp.DoubleTensor.Fmod*"></a>
  <h4 id="TorchSharp_DoubleTensor_Fmod_System_Double_" data-uid="TorchSharp.DoubleTensor.Fmod(System.Double)">Fmod(Double)</h4>
  <div class="markdown level1 summary"><p>Performs the Fmod operation on each element of the tensor with the
              <see paramref="value"></see> and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Fmod (double value);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_DoubleTensor_Fmod_System_Double__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>If you want to avoid the allocation of a new tensor, you can use the 
              alternative method <span class="xref">PytorchSharp.Fmod(PytorchSharp.DoubleTensor, Double, PytorchSharp.Double)</span>.</p>
</div>
  
  
  <a id="TorchSharp_DoubleTensor_Fmod_" data-uid="TorchSharp.DoubleTensor.Fmod*"></a>
  <h4 id="TorchSharp_DoubleTensor_Fmod_TorchSharp_DoubleTensor_System_Double_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Fmod(TorchSharp.DoubleTensor,System.Double,TorchSharp.DoubleTensor)">Fmod(DoubleTensor, Double, DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs the Fmod operation on each element of the source with the
              provided scalar.   The result tensor specified as the last parameters
              is resized to match the source.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public static void Fmod (TorchSharp.DoubleTensor source, double value, TorchSharp.DoubleTensor result);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>Source tensor on which the operation will take place.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>The scalar value that the operation uses.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">result</span></td>
        <td><p>The tensor where the result will be placed</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_DoubleTensor_Fmod_TorchSharp_DoubleTensor_System_Double_TorchSharp_DoubleTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>For each element in the <see paramref="source"></see> performs the Fmod operation
               with <see paramref="value"></see>.   The result is stored in the <see paramref="result"></see>
               tensor.</p>
</div>
  
  
  <a id="TorchSharp_DoubleTensor_Frac_" data-uid="TorchSharp.DoubleTensor.Frac*"></a>
  <h4 id="TorchSharp_DoubleTensor_Frac" data-uid="TorchSharp.DoubleTensor.Frac">Frac()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Frac of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Frac ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Frac_" data-uid="TorchSharp.DoubleTensor.Frac*"></a>
  <h4 id="TorchSharp_DoubleTensor_Frac_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Frac(TorchSharp.DoubleTensor)">Frac(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Frac of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Frac (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Gather_" data-uid="TorchSharp.DoubleTensor.Gather*"></a>
  <h4 id="TorchSharp_DoubleTensor_Gather_TorchSharp_DoubleTensor_System_Int32_TorchSharp_LongTensor_" data-uid="TorchSharp.DoubleTensor.Gather(TorchSharp.DoubleTensor,System.Int32,TorchSharp.LongTensor)">Gather(DoubleTensor, Int32, LongTensor)</h4>
  <div class="markdown level1 summary"><p>Gather</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Gather (TorchSharp.DoubleTensor src, int dim, TorchSharp.LongTensor index);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dim</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a></td>
        <td><span class="parametername">index</span></td>
        <td><p>Indices of entries to copy.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Geometric_" data-uid="TorchSharp.DoubleTensor.Geometric*"></a>
  <h4 id="TorchSharp_DoubleTensor_Geometric_TorchSharp_RandomGenerator_System_Double_" data-uid="TorchSharp.DoubleTensor.Geometric(TorchSharp.RandomGenerator,System.Double)">Geometric(RandomGenerator, Double)</h4>
  <div class="markdown level1 summary"><p>Populates the tensor with random values from 0 to n, using the provided random source generator.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Geometric (TorchSharp.RandomGenerator source, double p);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.RandomGenerator.html">RandomGenerator</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>The random generator source</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">p</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_GeTensor_" data-uid="TorchSharp.DoubleTensor.GeTensor*"></a>
  <h4 id="TorchSharp_DoubleTensor_GeTensor_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.GeTensor(TorchSharp.DoubleTensor)">GeTensor(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an GeTensor of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.ByteTensor GeTensor (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ByteTensor.html">ByteTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_GeTensorT_" data-uid="TorchSharp.DoubleTensor.GeTensorT*"></a>
  <h4 id="TorchSharp_DoubleTensor_GeTensorT_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.GeTensorT(TorchSharp.DoubleTensor)">GeTensorT(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an GeTensorT of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor GeTensorT (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_GetTensorDimension_" data-uid="TorchSharp.DoubleTensor.GetTensorDimension*"></a>
  <h4 id="TorchSharp_DoubleTensor_GetTensorDimension_System_Int32_" data-uid="TorchSharp.DoubleTensor.GetTensorDimension(System.Int32)">GetTensorDimension(Int32)</h4>
  <div class="markdown level1 summary"><p>Retrieves the size of the specified dimension in the tensor.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public long GetTensorDimension (int dim);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dim</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_GetTensorStride_" data-uid="TorchSharp.DoubleTensor.GetTensorStride*"></a>
  <h4 id="TorchSharp_DoubleTensor_GetTensorStride_System_Int32_" data-uid="TorchSharp.DoubleTensor.GetTensorStride(System.Int32)">GetTensorStride(Int32)</h4>
  <div class="markdown level1 summary"><p>Retrieves the stride of the specified dimension in the tensor.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public long GetTensorStride (int dim);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dim</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_GeValue_" data-uid="TorchSharp.DoubleTensor.GeValue*"></a>
  <h4 id="TorchSharp_DoubleTensor_GeValue_System_Double_" data-uid="TorchSharp.DoubleTensor.GeValue(System.Double)">GeValue(Double)</h4>
  <div class="markdown level1 summary"><p>Performs an GeValue of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.ByteTensor GeValue (double src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ByteTensor.html">ByteTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_GeValueT_" data-uid="TorchSharp.DoubleTensor.GeValueT*"></a>
  <h4 id="TorchSharp_DoubleTensor_GeValueT_System_Double_" data-uid="TorchSharp.DoubleTensor.GeValueT(System.Double)">GeValueT(Double)</h4>
  <div class="markdown level1 summary"><p>Performs an GeValueT of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor GeValueT (double src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_GtTensor_" data-uid="TorchSharp.DoubleTensor.GtTensor*"></a>
  <h4 id="TorchSharp_DoubleTensor_GtTensor_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.GtTensor(TorchSharp.DoubleTensor)">GtTensor(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an GtTensor of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.ByteTensor GtTensor (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ByteTensor.html">ByteTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_GtTensorT_" data-uid="TorchSharp.DoubleTensor.GtTensorT*"></a>
  <h4 id="TorchSharp_DoubleTensor_GtTensorT_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.GtTensorT(TorchSharp.DoubleTensor)">GtTensorT(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an GtTensorT of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor GtTensorT (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_GtValue_" data-uid="TorchSharp.DoubleTensor.GtValue*"></a>
  <h4 id="TorchSharp_DoubleTensor_GtValue_System_Double_" data-uid="TorchSharp.DoubleTensor.GtValue(System.Double)">GtValue(Double)</h4>
  <div class="markdown level1 summary"><p>Performs an GtValue of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.ByteTensor GtValue (double src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ByteTensor.html">ByteTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_GtValueT_" data-uid="TorchSharp.DoubleTensor.GtValueT*"></a>
  <h4 id="TorchSharp_DoubleTensor_GtValueT_System_Double_" data-uid="TorchSharp.DoubleTensor.GtValueT(System.Double)">GtValueT(Double)</h4>
  <div class="markdown level1 summary"><p>Performs an GtValueT of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor GtValueT (double src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Histc_" data-uid="TorchSharp.DoubleTensor.Histc*"></a>
  <h4 id="TorchSharp_DoubleTensor_Histc_System_Int64_System_Double_System_Double_" data-uid="TorchSharp.DoubleTensor.Histc(System.Int64,System.Double,System.Double)">Histc(Int64, Double, Double)</h4>
  <div class="markdown level1 summary"><p>Create a histogram of all tensor elements.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Histc (long nbins, double minvalue, double maxvalue);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">nbins</span></td>
        <td><p>The number of bins in the output histogram.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">minvalue</span></td>
        <td><p>Only consider values equal to or greater than this.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">maxvalue</span></td>
        <td><p>Only consider values equal to or less than this.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_IndexAdd_" data-uid="TorchSharp.DoubleTensor.IndexAdd*"></a>
  <h4 id="TorchSharp_DoubleTensor_IndexAdd_System_Int32_TorchSharp_LongTensor_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.IndexAdd(System.Int32,TorchSharp.LongTensor,TorchSharp.DoubleTensor)">IndexAdd(Int32, LongTensor, DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Adds the elements of tensor into the original tensor by selecting the indices in the order 
              given in index. The shape of tensor must exactly match the elements indexed or an error will be thrown.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void IndexAdd (int dim, TorchSharp.LongTensor index, TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dim</span></td>
        <td><p>Dimension to select for the add</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a></td>
        <td><span class="parametername">index</span></td>
        <td><p>Entries to copy</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>Tensor to copy the data from.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_IndexCopy_" data-uid="TorchSharp.DoubleTensor.IndexCopy*"></a>
  <h4 id="TorchSharp_DoubleTensor_IndexCopy_System_Int32_TorchSharp_LongTensor_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.IndexCopy(System.Int32,TorchSharp.LongTensor,TorchSharp.DoubleTensor)">IndexCopy(Int32, LongTensor, DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Copies the elements of tensor into the original tensor by selecting the indices in the order 
              given in index. The shape of tensor must exactly match the elements indexed or an error will be thrown.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void IndexCopy (int dim, TorchSharp.LongTensor index, TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dim</span></td>
        <td><p>Dimension to select for the copy</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a></td>
        <td><span class="parametername">index</span></td>
        <td><p>Entries to copy</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>Tensor to copy the data from.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_IndexFill_" data-uid="TorchSharp.DoubleTensor.IndexFill*"></a>
  <h4 id="TorchSharp_DoubleTensor_IndexFill_System_Int32_TorchSharp_LongTensor_System_Double_" data-uid="TorchSharp.DoubleTensor.IndexFill(System.Int32,TorchSharp.LongTensor,System.Double)">IndexFill(Int32, LongTensor, Double)</h4>
  <div class="markdown level1 summary"><p>Uses the given value to overwrite the original tensor by selecting the indices in the order 
              given in index. The shape of tensor must exactly match the elements indexed or an error will be thrown.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void IndexFill (int dim, TorchSharp.LongTensor index, double value);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dim</span></td>
        <td><p>Dimension to select for the fill</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a></td>
        <td><span class="parametername">index</span></td>
        <td><p>Entries to copy</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>The value to write.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_IndexSelect_" data-uid="TorchSharp.DoubleTensor.IndexSelect*"></a>
  <h4 id="TorchSharp_DoubleTensor_IndexSelect_System_Int32_TorchSharp_LongTensor_" data-uid="TorchSharp.DoubleTensor.IndexSelect(System.Int32,TorchSharp.LongTensor)">IndexSelect(Int32, LongTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new Tensor which indexes the original Tensor along dimension dim
              using the entries in index.  The returned Tensor has the same number of dimensions as the 
              original Tensor. The returned Tensor does not use the same storage as the original Tensor.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor IndexSelect (int dim, TorchSharp.LongTensor index);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dim</span></td>
        <td><p>Dimension to select</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a></td>
        <td><span class="parametername">index</span></td>
        <td><p>Entries to extract</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_KthValue_" data-uid="TorchSharp.DoubleTensor.KthValue*"></a>
  <h4 id="TorchSharp_DoubleTensor_KthValue_System_Int64_System_Int32_System_Boolean_" data-uid="TorchSharp.DoubleTensor.KthValue(System.Int64,System.Int32,System.Boolean)">KthValue(Int64, Int32, Boolean)</h4>
  <div class="markdown level1 summary"><p>Computes the kth value of all the elements of the tensor along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public Tuple&lt;TorchSharp.DoubleTensor,TorchSharp.LongTensor&gt; KthValue (long k, int dimension, bool keepdim);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">k</span></td>
        <td><p>The value for &#39;k&#39; in &#39;kth&#39;.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to process along.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">keepdim</span></td>
        <td><p>true if the reduction dimension should be kept, false otherwise.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Tuple</span>&lt;<a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a>,<a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a>&gt;</td>
        <td><p>A tuple containing the values and indices of the kth element of each dimension.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_LERP_" data-uid="TorchSharp.DoubleTensor.LERP*"></a>
  <h4 id="TorchSharp_DoubleTensor_LERP_TorchSharp_DoubleTensor_System_Double_" data-uid="TorchSharp.DoubleTensor.LERP(TorchSharp.DoubleTensor,System.Double)">LERP(DoubleTensor, Double)</h4>
  <div class="markdown level1 summary"><p>LERP</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor LERP (TorchSharp.DoubleTensor other, double weight);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">other</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">weight</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_LeTensor_" data-uid="TorchSharp.DoubleTensor.LeTensor*"></a>
  <h4 id="TorchSharp_DoubleTensor_LeTensor_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.LeTensor(TorchSharp.DoubleTensor)">LeTensor(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an LeTensor of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.ByteTensor LeTensor (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ByteTensor.html">ByteTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_LeTensorT_" data-uid="TorchSharp.DoubleTensor.LeTensorT*"></a>
  <h4 id="TorchSharp_DoubleTensor_LeTensorT_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.LeTensorT(TorchSharp.DoubleTensor)">LeTensorT(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an LeTensorT of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor LeTensorT (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_LeValue_" data-uid="TorchSharp.DoubleTensor.LeValue*"></a>
  <h4 id="TorchSharp_DoubleTensor_LeValue_System_Double_" data-uid="TorchSharp.DoubleTensor.LeValue(System.Double)">LeValue(Double)</h4>
  <div class="markdown level1 summary"><p>Performs an LeValue of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.ByteTensor LeValue (double src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ByteTensor.html">ByteTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_LeValueT_" data-uid="TorchSharp.DoubleTensor.LeValueT*"></a>
  <h4 id="TorchSharp_DoubleTensor_LeValueT_System_Double_" data-uid="TorchSharp.DoubleTensor.LeValueT(System.Double)">LeValueT(Double)</h4>
  <div class="markdown level1 summary"><p>Performs an LeValueT of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor LeValueT (double src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Lgamma_" data-uid="TorchSharp.DoubleTensor.Lgamma*"></a>
  <h4 id="TorchSharp_DoubleTensor_Lgamma" data-uid="TorchSharp.DoubleTensor.Lgamma">Lgamma()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Lgamma of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Lgamma ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Lgamma_" data-uid="TorchSharp.DoubleTensor.Lgamma*"></a>
  <h4 id="TorchSharp_DoubleTensor_Lgamma_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Lgamma(TorchSharp.DoubleTensor)">Lgamma(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Lgamma of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Lgamma (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Linspace_" data-uid="TorchSharp.DoubleTensor.Linspace*"></a>
  <h4 id="TorchSharp_DoubleTensor_Linspace_System_Double_System_Double_System_Int64_" data-uid="TorchSharp.DoubleTensor.Linspace(System.Double,System.Double,System.Int64)">Linspace(Double, Double, Int64)</h4>
  <div class="markdown level1 summary"><p>Performs Linspace of the tensor with the provided 
              <see paramref="src1"></see> and <see paramref="src1"></see> tensors and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Linspace (double a, double b, long n);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">a</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">b</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">n</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Log_" data-uid="TorchSharp.DoubleTensor.Log*"></a>
  <h4 id="TorchSharp_DoubleTensor_Log" data-uid="TorchSharp.DoubleTensor.Log">Log()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Log of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Log ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Log_" data-uid="TorchSharp.DoubleTensor.Log*"></a>
  <h4 id="TorchSharp_DoubleTensor_Log_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Log(TorchSharp.DoubleTensor)">Log(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Log of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Log (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Log10_" data-uid="TorchSharp.DoubleTensor.Log10*"></a>
  <h4 id="TorchSharp_DoubleTensor_Log10" data-uid="TorchSharp.DoubleTensor.Log10">Log10()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Log10 of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Log10 ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Log10_" data-uid="TorchSharp.DoubleTensor.Log10*"></a>
  <h4 id="TorchSharp_DoubleTensor_Log10_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Log10(TorchSharp.DoubleTensor)">Log10(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Log10 of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Log10 (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Log1p_" data-uid="TorchSharp.DoubleTensor.Log1p*"></a>
  <h4 id="TorchSharp_DoubleTensor_Log1p" data-uid="TorchSharp.DoubleTensor.Log1p">Log1p()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Log1p of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Log1p ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Log1p_" data-uid="TorchSharp.DoubleTensor.Log1p*"></a>
  <h4 id="TorchSharp_DoubleTensor_Log1p_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Log1p(TorchSharp.DoubleTensor)">Log1p(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Log1p of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Log1p (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Log2_" data-uid="TorchSharp.DoubleTensor.Log2*"></a>
  <h4 id="TorchSharp_DoubleTensor_Log2" data-uid="TorchSharp.DoubleTensor.Log2">Log2()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Log2 of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Log2 ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Log2_" data-uid="TorchSharp.DoubleTensor.Log2*"></a>
  <h4 id="TorchSharp_DoubleTensor_Log2_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Log2(TorchSharp.DoubleTensor)">Log2(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Log2 of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Log2 (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_LogNormal_" data-uid="TorchSharp.DoubleTensor.LogNormal*"></a>
  <h4 id="TorchSharp_DoubleTensor_LogNormal_TorchSharp_RandomGenerator_System_Double_System_Double_" data-uid="TorchSharp.DoubleTensor.LogNormal(TorchSharp.RandomGenerator,System.Double,System.Double)">LogNormal(RandomGenerator, Double, Double)</h4>
  <div class="markdown level1 summary"><p>Fills the tensor with values according to a log-normal distribution.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void LogNormal (TorchSharp.RandomGenerator source, double mean, double stdv);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.RandomGenerator.html">RandomGenerator</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>The random generator source</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">mean</span></td>
        <td><p>The mean of the distribution.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">stdv</span></td>
        <td><p>The standard deviation of the distribution.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Logspace_" data-uid="TorchSharp.DoubleTensor.Logspace*"></a>
  <h4 id="TorchSharp_DoubleTensor_Logspace_System_Double_System_Double_System_Int64_" data-uid="TorchSharp.DoubleTensor.Logspace(System.Double,System.Double,System.Int64)">Logspace(Double, Double, Int64)</h4>
  <div class="markdown level1 summary"><p>Performs Logspace of the tensor with the provided 
              <see paramref="src1"></see> and <see paramref="src1"></see> tensors and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Logspace (double a, double b, long n);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">a</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">b</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">n</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_LShift_" data-uid="TorchSharp.DoubleTensor.LShift*"></a>
  <h4 id="TorchSharp_DoubleTensor_LShift_TorchSharp_DoubleTensor_System_Double_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.LShift(TorchSharp.DoubleTensor,System.Double,TorchSharp.DoubleTensor)">LShift(DoubleTensor, Double, DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs the LShift operation on each element of the source with the
              provided scalar.   The result tensor specified as the last parameters
              is resized to match the source.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public static void LShift (TorchSharp.DoubleTensor source, double value, TorchSharp.DoubleTensor result);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>Source tensor on which the operation will take place.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>The scalar value that the operation uses.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">result</span></td>
        <td><p>The tensor where the result will be placed</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_DoubleTensor_LShift_TorchSharp_DoubleTensor_System_Double_TorchSharp_DoubleTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>For each element in the <see paramref="source"></see> performs the LShift operation
               with <see paramref="value"></see>.   The result is stored in the <see paramref="result"></see>
               tensor.</p>
</div>
  
  
  <a id="TorchSharp_DoubleTensor_LShift_" data-uid="TorchSharp.DoubleTensor.LShift*"></a>
  <h4 id="TorchSharp_DoubleTensor_LShift_System_Double_" data-uid="TorchSharp.DoubleTensor.LShift(System.Double)">LShift(Double)</h4>
  <div class="markdown level1 summary"><p>Performs the LShift operation on each element of the tensor with the
              <see paramref="value"></see> and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor LShift (double value);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_DoubleTensor_LShift_System_Double__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>If you want to avoid the allocation of a new tensor, you can use the 
              alternative method <span class="xref">PytorchSharp.LShift(PytorchSharp.DoubleTensor, Double, PytorchSharp.Double)</span>.</p>
</div>
  
  
  <a id="TorchSharp_DoubleTensor_LtTensor_" data-uid="TorchSharp.DoubleTensor.LtTensor*"></a>
  <h4 id="TorchSharp_DoubleTensor_LtTensor_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.LtTensor(TorchSharp.DoubleTensor)">LtTensor(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an LtTensor of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.ByteTensor LtTensor (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ByteTensor.html">ByteTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_LtTensorT_" data-uid="TorchSharp.DoubleTensor.LtTensorT*"></a>
  <h4 id="TorchSharp_DoubleTensor_LtTensorT_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.LtTensorT(TorchSharp.DoubleTensor)">LtTensorT(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an LtTensorT of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor LtTensorT (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_LtValue_" data-uid="TorchSharp.DoubleTensor.LtValue*"></a>
  <h4 id="TorchSharp_DoubleTensor_LtValue_System_Double_" data-uid="TorchSharp.DoubleTensor.LtValue(System.Double)">LtValue(Double)</h4>
  <div class="markdown level1 summary"><p>Performs an LtValue of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.ByteTensor LtValue (double src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ByteTensor.html">ByteTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_LtValueT_" data-uid="TorchSharp.DoubleTensor.LtValueT*"></a>
  <h4 id="TorchSharp_DoubleTensor_LtValueT_System_Double_" data-uid="TorchSharp.DoubleTensor.LtValueT(System.Double)">LtValueT(Double)</h4>
  <div class="markdown level1 summary"><p>Performs an LtValueT of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor LtValueT (double src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_MaskedCopy_" data-uid="TorchSharp.DoubleTensor.MaskedCopy*"></a>
  <h4 id="TorchSharp_DoubleTensor_MaskedCopy_TorchSharp_ByteTensor_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.MaskedCopy(TorchSharp.ByteTensor,TorchSharp.DoubleTensor)">MaskedCopy(ByteTensor, DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Copies elements from the source tensor to the locations indicated by the mask.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void MaskedCopy (TorchSharp.ByteTensor mask, TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ByteTensor.html">ByteTensor</a></td>
        <td><span class="parametername">mask</span></td>
        <td><p>A byte tensor with values 0 or 1 indicating the locations where in the destination the value should be filled.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The source tensor.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_DoubleTensor_MaskedCopy_TorchSharp_ByteTensor_TorchSharp_DoubleTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>There must be at least as many elements in the source tensor as there are 1s in the mask.</p>
</div>
  
  
  <a id="TorchSharp_DoubleTensor_MaskedFill_" data-uid="TorchSharp.DoubleTensor.MaskedFill*"></a>
  <h4 id="TorchSharp_DoubleTensor_MaskedFill_TorchSharp_ByteTensor_System_Double_" data-uid="TorchSharp.DoubleTensor.MaskedFill(TorchSharp.ByteTensor,System.Double)">MaskedFill(ByteTensor, Double)</h4>
  <div class="markdown level1 summary"><p>Fills the tensor with the specified value at the locations indicated by the mask.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void MaskedFill (TorchSharp.ByteTensor mask, double value);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ByteTensor.html">ByteTensor</a></td>
        <td><span class="parametername">mask</span></td>
        <td><p>A byte tensor with values 0 or 1 indicating the locations where the value should be filled.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>The value to write at the indicated locations.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_MaskedSelect_" data-uid="TorchSharp.DoubleTensor.MaskedSelect*"></a>
  <h4 id="TorchSharp_DoubleTensor_MaskedSelect_TorchSharp_ByteTensor_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.MaskedSelect(TorchSharp.ByteTensor,TorchSharp.DoubleTensor)">MaskedSelect(ByteTensor, DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Copies elements from the source tensor at the locations indicated by the mask.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void MaskedSelect (TorchSharp.ByteTensor mask, TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ByteTensor.html">ByteTensor</a></td>
        <td><span class="parametername">mask</span></td>
        <td><p>A byte tensor with values 0 or 1 indicating the locations where in the source the value should be fetched.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The source tensor.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_DoubleTensor_MaskedSelect_TorchSharp_ByteTensor_TorchSharp_DoubleTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>There will be as many elements in the tensor as there are 1s in the mask.
             There must be at least as many elements in the source tensor as there are 1s in the mask.</p>
</div>
  
  
  <a id="TorchSharp_DoubleTensor_Match_" data-uid="TorchSharp.DoubleTensor.Match*"></a>
  <h4 id="TorchSharp_DoubleTensor_Match_TorchSharp_DoubleTensor_System_Double_" data-uid="TorchSharp.DoubleTensor.Match(TorchSharp.DoubleTensor,System.Double)">Match(DoubleTensor, Double)</h4>
  <div class="markdown level1 summary"><p>Match</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Match (TorchSharp.DoubleTensor m2, double gain);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">m2</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">gain</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Max_" data-uid="TorchSharp.DoubleTensor.Max*"></a>
  <h4 id="TorchSharp_DoubleTensor_Max_System_Int32_System_Boolean_" data-uid="TorchSharp.DoubleTensor.Max(System.Int32,System.Boolean)">Max(Int32, Boolean)</h4>
  <div class="markdown level1 summary"><p>Computes the max of all the elements of the tensor along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public Tuple&lt;TorchSharp.DoubleTensor,TorchSharp.LongTensor&gt; Max (int dimension, bool keepdim);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to process along.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">keepdim</span></td>
        <td><p>true if the reduction dimension should be kept, false otherwise.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Tuple</span>&lt;<a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a>,<a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a>&gt;</td>
        <td><p>A tuple containing the values and indices of the resulting elements.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_MaxAll_" data-uid="TorchSharp.DoubleTensor.MaxAll*"></a>
  <h4 id="TorchSharp_DoubleTensor_MaxAll" data-uid="TorchSharp.DoubleTensor.MaxAll">MaxAll()</h4>
  <div class="markdown level1 summary"><p>Returns the maximum value of the elements in the tensor.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public double MaxAll ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><p>The maximum value of the tensor.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Mean_" data-uid="TorchSharp.DoubleTensor.Mean*"></a>
  <h4 id="TorchSharp_DoubleTensor_Mean_System_Int32_System_Boolean_" data-uid="TorchSharp.DoubleTensor.Mean(System.Int32,System.Boolean)">Mean(Int32, Boolean)</h4>
  <div class="markdown level1 summary"><p>Compute the mean of all tensor elements along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Mean (int dimension, bool keepdim);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to process along.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">keepdim</span></td>
        <td><p>true if the reduction dimension should be kept, false otherwise.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_MeanAll_" data-uid="TorchSharp.DoubleTensor.MeanAll*"></a>
  <h4 id="TorchSharp_DoubleTensor_MeanAll" data-uid="TorchSharp.DoubleTensor.MeanAll">MeanAll()</h4>
  <div class="markdown level1 summary"><p>Compute the mean of all tensor elements.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public double MeanAll ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><p>The mean of the tensor.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Median_" data-uid="TorchSharp.DoubleTensor.Median*"></a>
  <h4 id="TorchSharp_DoubleTensor_Median_System_Int32_System_Boolean_" data-uid="TorchSharp.DoubleTensor.Median(System.Int32,System.Boolean)">Median(Int32, Boolean)</h4>
  <div class="markdown level1 summary"><p>Computes the median of all the elements of the tensor along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public Tuple&lt;TorchSharp.DoubleTensor,TorchSharp.LongTensor&gt; Median (int dimension, bool keepdim);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to process along.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">keepdim</span></td>
        <td><p>true if the reduction dimension should be kept, false otherwise.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Tuple</span>&lt;<a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a>,<a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a>&gt;</td>
        <td><p>A tuple containing the values and indices of the resulting elements.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_MedianAll_" data-uid="TorchSharp.DoubleTensor.MedianAll*"></a>
  <h4 id="TorchSharp_DoubleTensor_MedianAll" data-uid="TorchSharp.DoubleTensor.MedianAll">MedianAll()</h4>
  <div class="markdown level1 summary"><p>Returns the median of the elements in the tensor.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public double MedianAll ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><p>The median of the tensor.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Min_" data-uid="TorchSharp.DoubleTensor.Min*"></a>
  <h4 id="TorchSharp_DoubleTensor_Min_System_Int32_System_Boolean_" data-uid="TorchSharp.DoubleTensor.Min(System.Int32,System.Boolean)">Min(Int32, Boolean)</h4>
  <div class="markdown level1 summary"><p>Computes the min of all the elements of the tensor along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public Tuple&lt;TorchSharp.DoubleTensor,TorchSharp.LongTensor&gt; Min (int dimension, bool keepdim);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to process along.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">keepdim</span></td>
        <td><p>true if the reduction dimension should be kept, false otherwise.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Tuple</span>&lt;<a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a>,<a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a>&gt;</td>
        <td><p>A tuple containing the values and indices of the resulting elements.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_MinAll_" data-uid="TorchSharp.DoubleTensor.MinAll*"></a>
  <h4 id="TorchSharp_DoubleTensor_MinAll" data-uid="TorchSharp.DoubleTensor.MinAll">MinAll()</h4>
  <div class="markdown level1 summary"><p>Returns the minimum value of the elements in the tensor.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public double MinAll ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><p>The minimum value of the tensor.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Mode_" data-uid="TorchSharp.DoubleTensor.Mode*"></a>
  <h4 id="TorchSharp_DoubleTensor_Mode_System_Int32_System_Boolean_" data-uid="TorchSharp.DoubleTensor.Mode(System.Int32,System.Boolean)">Mode(Int32, Boolean)</h4>
  <div class="markdown level1 summary"><p>Computes the mode of all the elements of the tensor along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public Tuple&lt;TorchSharp.DoubleTensor,TorchSharp.LongTensor&gt; Mode (int dimension, bool keepdim);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to process along.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">keepdim</span></td>
        <td><p>true if the reduction dimension should be kept, false otherwise.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Tuple</span>&lt;<a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a>,<a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a>&gt;</td>
        <td><p>A tuple containing the values and indices of the resulting elements.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Mul_" data-uid="TorchSharp.DoubleTensor.Mul*"></a>
  <h4 id="TorchSharp_DoubleTensor_Mul_System_Double_" data-uid="TorchSharp.DoubleTensor.Mul(System.Double)">Mul(Double)</h4>
  <div class="markdown level1 summary"><p>Performs the Mul operation on each element of the tensor with the
              <see paramref="value"></see> and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Mul (double value);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_DoubleTensor_Mul_System_Double__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>If you want to avoid the allocation of a new tensor, you can use the 
              alternative method <span class="xref">PytorchSharp.Mul(PytorchSharp.DoubleTensor, Double, PytorchSharp.Double)</span>.</p>
</div>
  
  
  <a id="TorchSharp_DoubleTensor_Mul_" data-uid="TorchSharp.DoubleTensor.Mul*"></a>
  <h4 id="TorchSharp_DoubleTensor_Mul_TorchSharp_DoubleTensor_System_Double_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Mul(TorchSharp.DoubleTensor,System.Double,TorchSharp.DoubleTensor)">Mul(DoubleTensor, Double, DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs the Mul operation on each element of the source with the
              provided scalar.   The result tensor specified as the last parameters
              is resized to match the source.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public static void Mul (TorchSharp.DoubleTensor source, double value, TorchSharp.DoubleTensor result);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>Source tensor on which the operation will take place.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>The scalar value that the operation uses.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">result</span></td>
        <td><p>The tensor where the result will be placed</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_DoubleTensor_Mul_TorchSharp_DoubleTensor_System_Double_TorchSharp_DoubleTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>For each element in the <see paramref="source"></see> performs the Mul operation
               with <see paramref="value"></see>.   The result is stored in the <see paramref="result"></see>
               tensor.</p>
</div>
  
  
  <a id="TorchSharp_DoubleTensor_Multinomial_" data-uid="TorchSharp.DoubleTensor.Multinomial*"></a>
  <h4 id="TorchSharp_DoubleTensor_Multinomial_TorchSharp_RandomGenerator_TorchSharp_DoubleTensor_System_Int32_System_Int32_" data-uid="TorchSharp.DoubleTensor.Multinomial(TorchSharp.RandomGenerator,TorchSharp.DoubleTensor,System.Int32,System.Int32)">Multinomial(RandomGenerator, DoubleTensor, Int32, Int32)</h4>
  <div class="markdown level1 summary"><p>Fills the tensor with values according to a multinomial distribution.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Multinomial (TorchSharp.RandomGenerator source, TorchSharp.DoubleTensor prob_dist, int n_sample, int with_replacement);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.RandomGenerator.html">RandomGenerator</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>The random generator source</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">prob_dist</span></td>
        <td><p>The probability for each bucket.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">n_sample</span></td>
        <td><p>The number of samples to generate.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">with_replacement</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Narrow_" data-uid="TorchSharp.DoubleTensor.Narrow*"></a>
  <h4 id="TorchSharp_DoubleTensor_Narrow_System_Int32_System_Int64_System_Int64_" data-uid="TorchSharp.DoubleTensor.Narrow(System.Int32,System.Int64,System.Int64)">Narrow(Int32, Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Returns a new Tensor which is a narrowed version of the current one: the dimension dim is narrowed from firstIndexto firstIndex+size-1.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Narrow (int dim, long firstIndex, long size);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dim</span></td>
        <td><p>The dimension to narrow</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">firstIndex</span></td>
        <td><p>Initial index to narrow</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size</span></td>
        <td><p>Number of elements</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_neg_" data-uid="TorchSharp.DoubleTensor.neg*"></a>
  <h4 id="TorchSharp_DoubleTensor_neg" data-uid="TorchSharp.DoubleTensor.neg">neg()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the neg of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor neg ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_neg_" data-uid="TorchSharp.DoubleTensor.neg*"></a>
  <h4 id="TorchSharp_DoubleTensor_neg_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.neg(TorchSharp.DoubleTensor)">neg(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the neg of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor neg (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_NeTensor_" data-uid="TorchSharp.DoubleTensor.NeTensor*"></a>
  <h4 id="TorchSharp_DoubleTensor_NeTensor_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.NeTensor(TorchSharp.DoubleTensor)">NeTensor(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an NeTensor of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.ByteTensor NeTensor (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ByteTensor.html">ByteTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_NeTensorT_" data-uid="TorchSharp.DoubleTensor.NeTensorT*"></a>
  <h4 id="TorchSharp_DoubleTensor_NeTensorT_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.NeTensorT(TorchSharp.DoubleTensor)">NeTensorT(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an NeTensorT of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor NeTensorT (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_NeValue_" data-uid="TorchSharp.DoubleTensor.NeValue*"></a>
  <h4 id="TorchSharp_DoubleTensor_NeValue_System_Double_" data-uid="TorchSharp.DoubleTensor.NeValue(System.Double)">NeValue(Double)</h4>
  <div class="markdown level1 summary"><p>Performs an NeValue of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.ByteTensor NeValue (double src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ByteTensor.html">ByteTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_NeValueT_" data-uid="TorchSharp.DoubleTensor.NeValueT*"></a>
  <h4 id="TorchSharp_DoubleTensor_NeValueT_System_Double_" data-uid="TorchSharp.DoubleTensor.NeValueT(System.Double)">NeValueT(Double)</h4>
  <div class="markdown level1 summary"><p>Performs an NeValueT of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor NeValueT (double src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_NewWithStorage1d_" data-uid="TorchSharp.DoubleTensor.NewWithStorage1d*"></a>
  <h4 id="TorchSharp_DoubleTensor_NewWithStorage1d_System_IntPtr_System_Int64_System_Int64_" data-uid="TorchSharp.DoubleTensor.NewWithStorage1d(System.IntPtr,System.Int64,System.Int64)">NewWithStorage1d(IntPtr, Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Access to element at the specified position in the tensor</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor NewWithStorage1d (IntPtr offset, long size, long stride);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.IntPtr</span></td>
        <td><span class="parametername">offset</span></td>
        <td><p>Offset within the input storage the storage of the new tensor will start from.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size</span></td>
        <td><p>Size of the first dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">stride</span></td>
        <td><p>Stride of the first dimension.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_NewWithStorage2d_" data-uid="TorchSharp.DoubleTensor.NewWithStorage2d*"></a>
  <h4 id="TorchSharp_DoubleTensor_NewWithStorage2d_System_IntPtr_System_Int64_System_Int64_System_Int64_System_Int64_" data-uid="TorchSharp.DoubleTensor.NewWithStorage2d(System.IntPtr,System.Int64,System.Int64,System.Int64,System.Int64)">NewWithStorage2d(IntPtr, Int64, Int64, Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Access to element at the specified position in the tensor</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor NewWithStorage2d (IntPtr offset, long size0, long stride0, long size1, long stride1);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.IntPtr</span></td>
        <td><span class="parametername">offset</span></td>
        <td><p>Offset within the input storage the storage of the new tensor will start from.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size0</span></td>
        <td><p>Size of the first dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">stride0</span></td>
        <td><p>Stride of the first dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size1</span></td>
        <td><p>Size of the second dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">stride1</span></td>
        <td><p>Stride of the second dimension.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_NewWithStorage3d_" data-uid="TorchSharp.DoubleTensor.NewWithStorage3d*"></a>
  <h4 id="TorchSharp_DoubleTensor_NewWithStorage3d_System_IntPtr_System_Int64_System_Int64_System_Int64_System_Int64_System_Int64_System_Int64_" data-uid="TorchSharp.DoubleTensor.NewWithStorage3d(System.IntPtr,System.Int64,System.Int64,System.Int64,System.Int64,System.Int64,System.Int64)">NewWithStorage3d(IntPtr, Int64, Int64, Int64, Int64, Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Access to element at the specified position in the tensor</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor NewWithStorage3d (IntPtr offset, long size0, long stride0, long size1, long stride1, long size2, long stride2);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.IntPtr</span></td>
        <td><span class="parametername">offset</span></td>
        <td><p>Offset within the input storage the storage of the new tensor will start from.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size0</span></td>
        <td><p>Size of the first dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">stride0</span></td>
        <td><p>Stride of the first dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size1</span></td>
        <td><p>Size of the second dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">stride1</span></td>
        <td><p>Stride of the second dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size2</span></td>
        <td><p>Size of the third dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">stride2</span></td>
        <td><p>Stride of the third dimension.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_NewWithStorage4d_" data-uid="TorchSharp.DoubleTensor.NewWithStorage4d*"></a>
  <h4 id="TorchSharp_DoubleTensor_NewWithStorage4d_System_IntPtr_System_Int64_System_Int64_System_Int64_System_Int64_System_Int64_System_Int64_System_Int64_System_Int64_" data-uid="TorchSharp.DoubleTensor.NewWithStorage4d(System.IntPtr,System.Int64,System.Int64,System.Int64,System.Int64,System.Int64,System.Int64,System.Int64,System.Int64)">NewWithStorage4d(IntPtr, Int64, Int64, Int64, Int64, Int64, Int64, Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Access to element at the specified position in the tensor</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor NewWithStorage4d (IntPtr offset, long size0, long stride0, long size1, long stride1, long size2, long stride2, long size3, long stride3);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.IntPtr</span></td>
        <td><span class="parametername">offset</span></td>
        <td><p>Offset within the input storage the storage of the new tensor will start from.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size0</span></td>
        <td><p>Size of the first dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">stride0</span></td>
        <td><p>Stride of the first dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size1</span></td>
        <td><p>Size of the second dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">stride1</span></td>
        <td><p>Stride of the second dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size2</span></td>
        <td><p>Size of the third dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">stride2</span></td>
        <td><p>Stride of the third dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size3</span></td>
        <td><p>Size of the fourth dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">stride3</span></td>
        <td><p>Stride of the fourth dimension.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_NonZero_" data-uid="TorchSharp.DoubleTensor.NonZero*"></a>
  <h4 id="TorchSharp_DoubleTensor_NonZero" data-uid="TorchSharp.DoubleTensor.NonZero">NonZero()</h4>
  <div class="markdown level1 summary"><p>Finds the indices of all non-zero elements.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.LongTensor NonZero ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Norm_" data-uid="TorchSharp.DoubleTensor.Norm*"></a>
  <h4 id="TorchSharp_DoubleTensor_Norm_System_Double_System_Int32_System_Boolean_" data-uid="TorchSharp.DoubleTensor.Norm(System.Double,System.Int32,System.Boolean)">Norm(Double, Int32, Boolean)</h4>
  <div class="markdown level1 summary"><p>Compute the norm of all tensor elements along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Norm (double value, int dimension, bool keepdim);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to process along.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">keepdim</span></td>
        <td><p>true if the reduction dimension should be kept, false otherwise.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Normal_" data-uid="TorchSharp.DoubleTensor.Normal*"></a>
  <h4 id="TorchSharp_DoubleTensor_Normal_TorchSharp_RandomGenerator_System_Double_System_Double_" data-uid="TorchSharp.DoubleTensor.Normal(TorchSharp.RandomGenerator,System.Double,System.Double)">Normal(RandomGenerator, Double, Double)</h4>
  <div class="markdown level1 summary"><p>Fills the tensor with values according to a normal distribution.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Normal (TorchSharp.RandomGenerator source, double mean, double stdv);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.RandomGenerator.html">RandomGenerator</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>The random generator source</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">mean</span></td>
        <td><p>The mean of the distribution.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">stdv</span></td>
        <td><p>The standard deviation of the distribution.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_NormAll_" data-uid="TorchSharp.DoubleTensor.NormAll*"></a>
  <h4 id="TorchSharp_DoubleTensor_NormAll_System_Double_" data-uid="TorchSharp.DoubleTensor.NormAll(System.Double)">NormAll(Double)</h4>
  <div class="markdown level1 summary"><p>Compute the norm of all tensor elements.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public double NormAll (double value);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_NormalMeans_" data-uid="TorchSharp.DoubleTensor.NormalMeans*"></a>
  <h4 id="TorchSharp_DoubleTensor_NormalMeans_TorchSharp_RandomGenerator_TorchSharp_DoubleTensor_System_Double_" data-uid="TorchSharp.DoubleTensor.NormalMeans(TorchSharp.RandomGenerator,TorchSharp.DoubleTensor,System.Double)">NormalMeans(RandomGenerator, DoubleTensor, Double)</h4>
  <div class="markdown level1 summary"><p>Fills the tensor with values according to a normal distribution. This version uses multiple means.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void NormalMeans (TorchSharp.RandomGenerator source, TorchSharp.DoubleTensor means, double stdv);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.RandomGenerator.html">RandomGenerator</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>The random generator source</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">means</span></td>
        <td><p>The means of the distribution.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">stdv</span></td>
        <td><p>The standard deviation of the distribution.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_NormalMeansStdvs_" data-uid="TorchSharp.DoubleTensor.NormalMeansStdvs*"></a>
  <h4 id="TorchSharp_DoubleTensor_NormalMeansStdvs_TorchSharp_RandomGenerator_TorchSharp_DoubleTensor_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.NormalMeansStdvs(TorchSharp.RandomGenerator,TorchSharp.DoubleTensor,TorchSharp.DoubleTensor)">NormalMeansStdvs(RandomGenerator, DoubleTensor, DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Fills the tensor with values according to a normal distribution. This version uses multiple means and standard deviations.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void NormalMeansStdvs (TorchSharp.RandomGenerator source, TorchSharp.DoubleTensor means, TorchSharp.DoubleTensor stdvs);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.RandomGenerator.html">RandomGenerator</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>The random generator source</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">means</span></td>
        <td><p>The means of the distribution.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">stdvs</span></td>
        <td><p>The standards deviation of the distribution.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_NormalStdvs_" data-uid="TorchSharp.DoubleTensor.NormalStdvs*"></a>
  <h4 id="TorchSharp_DoubleTensor_NormalStdvs_TorchSharp_RandomGenerator_System_Double_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.NormalStdvs(TorchSharp.RandomGenerator,System.Double,TorchSharp.DoubleTensor)">NormalStdvs(RandomGenerator, Double, DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Fills the tensor with values according to a normal distribution. This version uses multiple standard deviations.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void NormalStdvs (TorchSharp.RandomGenerator source, double mean, TorchSharp.DoubleTensor stdvs);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.RandomGenerator.html">RandomGenerator</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>The random generator source</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">mean</span></td>
        <td><p>The mean of the distribution.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">stdvs</span></td>
        <td><p>The standard deviations of the distribution.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_NumElements_" data-uid="TorchSharp.DoubleTensor.NumElements*"></a>
  <h4 id="TorchSharp_DoubleTensor_NumElements" data-uid="TorchSharp.DoubleTensor.NumElements">NumElements()</h4>
  <div class="markdown level1 summary"><p>Get the number of elements in the tensor.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public long NumElements ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_OnesLike_" data-uid="TorchSharp.DoubleTensor.OnesLike*"></a>
  <h4 id="TorchSharp_DoubleTensor_OnesLike" data-uid="TorchSharp.DoubleTensor.OnesLike">OnesLike()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the OnesLike of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor OnesLike ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Polygamma_" data-uid="TorchSharp.DoubleTensor.Polygamma*"></a>
  <h4 id="TorchSharp_DoubleTensor_Polygamma" data-uid="TorchSharp.DoubleTensor.Polygamma">Polygamma()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Polygamma of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Polygamma ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Polygamma_" data-uid="TorchSharp.DoubleTensor.Polygamma*"></a>
  <h4 id="TorchSharp_DoubleTensor_Polygamma_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Polygamma(TorchSharp.DoubleTensor)">Polygamma(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Polygamma of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Polygamma (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Pow_" data-uid="TorchSharp.DoubleTensor.Pow*"></a>
  <h4 id="TorchSharp_DoubleTensor_Pow_System_Double_" data-uid="TorchSharp.DoubleTensor.Pow(System.Double)">Pow(Double)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with <see paramref="this"></see> raised to the power of <see paramref="y"></see>.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Pow (double y);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">y</span></td>
        <td><p>The exponent.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Prod_" data-uid="TorchSharp.DoubleTensor.Prod*"></a>
  <h4 id="TorchSharp_DoubleTensor_Prod_System_Int32_System_Boolean_" data-uid="TorchSharp.DoubleTensor.Prod(System.Int32,System.Boolean)">Prod(Int32, Boolean)</h4>
  <div class="markdown level1 summary"><p>Computes the product of all the elements of the tensor along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Prod (int dimension, bool keepdim);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to process along.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">keepdim</span></td>
        <td><p>true if the reduction dimension should be kept, false otherwise.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_ProdAll_" data-uid="TorchSharp.DoubleTensor.ProdAll*"></a>
  <h4 id="TorchSharp_DoubleTensor_ProdAll" data-uid="TorchSharp.DoubleTensor.ProdAll">ProdAll()</h4>
  <div class="markdown level1 summary"><p>Returns the product of the elements in the tensor.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public double ProdAll ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><p>The product of the tensor.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Put_" data-uid="TorchSharp.DoubleTensor.Put*"></a>
  <h4 id="TorchSharp_DoubleTensor_Put_TorchSharp_LongTensor_TorchSharp_DoubleTensor_System_Boolean_" data-uid="TorchSharp.DoubleTensor.Put(TorchSharp.LongTensor,TorchSharp.DoubleTensor,System.Boolean)">Put(LongTensor, DoubleTensor, Boolean)</h4>
  <div class="markdown level1 summary"><p>Put</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Put (TorchSharp.LongTensor index, TorchSharp.DoubleTensor src, bool accumulate);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a></td>
        <td><span class="parametername">index</span></td>
        <td><p>Indices of entries to copy.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">accumulate</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Random_" data-uid="TorchSharp.DoubleTensor.Random*"></a>
  <h4 id="TorchSharp_DoubleTensor_Random_TorchSharp_RandomGenerator_" data-uid="TorchSharp.DoubleTensor.Random(TorchSharp.RandomGenerator)">Random(RandomGenerator)</h4>
  <div class="markdown level1 summary"><p>Populates the tensor with random values using the provided random source generator.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Random (TorchSharp.RandomGenerator source);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.RandomGenerator.html">RandomGenerator</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>The random generator source</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Random_" data-uid="TorchSharp.DoubleTensor.Random*"></a>
  <h4 id="TorchSharp_DoubleTensor_Random_TorchSharp_RandomGenerator_System_Int64_" data-uid="TorchSharp.DoubleTensor.Random(TorchSharp.RandomGenerator,System.Int64)">Random(RandomGenerator, Int64)</h4>
  <div class="markdown level1 summary"><p>Populates the tensor with random values from 0 to n, using the provided random source generator.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Random (TorchSharp.RandomGenerator source, long n);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.RandomGenerator.html">RandomGenerator</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>The random generator source</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">n</span></td>
        <td><p>The upper limit for the values to be generated</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Random_" data-uid="TorchSharp.DoubleTensor.Random*"></a>
  <h4 id="TorchSharp_DoubleTensor_Random_System_Int64_" data-uid="TorchSharp.DoubleTensor.Random(System.Int64)">Random(Int64)</h4>
  <div class="markdown level1 summary"><p>Populates the tensor with random values from 0 to n, using a newly initialized Random number geneator.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Random (long n);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">n</span></td>
        <td><p>The upper limit for the values to be generated</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_RandPerm_" data-uid="TorchSharp.DoubleTensor.RandPerm*"></a>
  <h4 id="TorchSharp_DoubleTensor_RandPerm_TorchSharp_RandomGenerator_System_Int64_" data-uid="TorchSharp.DoubleTensor.RandPerm(TorchSharp.RandomGenerator,System.Int64)">RandPerm(RandomGenerator, Int64)</h4>
  <div class="markdown level1 summary"><p>Populates the tensor with random values from 0 to n, using the provided random source generator.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void RandPerm (TorchSharp.RandomGenerator source, long max);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.RandomGenerator.html">RandomGenerator</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>The random generator source</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">max</span></td>
        <td><p>The upper limit for the values to be generated</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Range_" data-uid="TorchSharp.DoubleTensor.Range*"></a>
  <h4 id="TorchSharp_DoubleTensor_Range_System_Double_System_Double_System_Double_" data-uid="TorchSharp.DoubleTensor.Range(System.Double,System.Double,System.Double)">Range(Double, Double, Double)</h4>
  <div class="markdown level1 summary"><p>Create a range spanning from xmin to xmax, with &#39;step&#39; between each value.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public static TorchSharp.DoubleTensor Range (double xmin, double xmax, double step);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">xmin</span></td>
        <td><p>The lower bound of the range.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">xmax</span></td>
        <td><p>The upper bound of the range.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">step</span></td>
        <td><p>The value step.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Remainder_" data-uid="TorchSharp.DoubleTensor.Remainder*"></a>
  <h4 id="TorchSharp_DoubleTensor_Remainder_System_Double_" data-uid="TorchSharp.DoubleTensor.Remainder(System.Double)">Remainder(Double)</h4>
  <div class="markdown level1 summary"><p>Performs the Remainder operation on each element of the tensor with the
              <see paramref="value"></see> and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Remainder (double value);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_DoubleTensor_Remainder_System_Double__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>If you want to avoid the allocation of a new tensor, you can use the 
              alternative method <span class="xref">PytorchSharp.Remainder(PytorchSharp.DoubleTensor, Double, PytorchSharp.Double)</span>.</p>
</div>
  
  
  <a id="TorchSharp_DoubleTensor_Remainder_" data-uid="TorchSharp.DoubleTensor.Remainder*"></a>
  <h4 id="TorchSharp_DoubleTensor_Remainder_TorchSharp_DoubleTensor_System_Double_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Remainder(TorchSharp.DoubleTensor,System.Double,TorchSharp.DoubleTensor)">Remainder(DoubleTensor, Double, DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs the Remainder operation on each element of the source with the
              provided scalar.   The result tensor specified as the last parameters
              is resized to match the source.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public static void Remainder (TorchSharp.DoubleTensor source, double value, TorchSharp.DoubleTensor result);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>Source tensor on which the operation will take place.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>The scalar value that the operation uses.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">result</span></td>
        <td><p>The tensor where the result will be placed</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_DoubleTensor_Remainder_TorchSharp_DoubleTensor_System_Double_TorchSharp_DoubleTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>For each element in the <see paramref="source"></see> performs the Remainder operation
               with <see paramref="value"></see>.   The result is stored in the <see paramref="result"></see>
               tensor.</p>
</div>
  
  
  <a id="TorchSharp_DoubleTensor_Renorm_" data-uid="TorchSharp.DoubleTensor.Renorm*"></a>
  <h4 id="TorchSharp_DoubleTensor_Renorm_System_Double_System_Int32_System_Double_" data-uid="TorchSharp.DoubleTensor.Renorm(System.Double,System.Int32,System.Double)">Renorm(Double, Int32, Double)</h4>
  <div class="markdown level1 summary"><p>Compute the renorm of all tensor elements along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Renorm (double value, int dimension, double maxnorm);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to process along.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">maxnorm</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Resize1d_" data-uid="TorchSharp.DoubleTensor.Resize1d*"></a>
  <h4 id="TorchSharp_DoubleTensor_Resize1d_System_Int64_" data-uid="TorchSharp.DoubleTensor.Resize1d(System.Int64)">Resize1d(Int64)</h4>
  <div class="markdown level1 summary"><p>Resizes the tensor to be one dimensional with the specified size, the contents of the tensor after this are undetermined.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Resize1d (long size);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size</span></td>
        <td><p>The desired new size for the first dimension of the tensor.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Resize2d_" data-uid="TorchSharp.DoubleTensor.Resize2d*"></a>
  <h4 id="TorchSharp_DoubleTensor_Resize2d_System_Int64_System_Int64_" data-uid="TorchSharp.DoubleTensor.Resize2d(System.Int64,System.Int64)">Resize2d(Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Resizes the tensor to be two dimensional with the specified size, the contents of the tensor after this are undetermined.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Resize2d (long size0, long size1);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size0</span></td>
        <td><p>The desired new size for the first dimension of the tensor.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size1</span></td>
        <td><p>The desired new size for the second dimension of the tensor.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Resize3d_" data-uid="TorchSharp.DoubleTensor.Resize3d*"></a>
  <h4 id="TorchSharp_DoubleTensor_Resize3d_System_Int64_System_Int64_System_Int64_" data-uid="TorchSharp.DoubleTensor.Resize3d(System.Int64,System.Int64,System.Int64)">Resize3d(Int64, Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Resizes the tensor to be three dimensional with the specified size, the contents of the tensor after this are undetermined.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Resize3d (long size0, long size1, long size2);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size0</span></td>
        <td><p>The desired new size for the first dimension of the tensor.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size1</span></td>
        <td><p>The desired new size for the second dimension of the tensor.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size2</span></td>
        <td><p>The desired new size for the third dimension of the tensor.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Resize4d_" data-uid="TorchSharp.DoubleTensor.Resize4d*"></a>
  <h4 id="TorchSharp_DoubleTensor_Resize4d_System_Int64_System_Int64_System_Int64_System_Int64_" data-uid="TorchSharp.DoubleTensor.Resize4d(System.Int64,System.Int64,System.Int64,System.Int64)">Resize4d(Int64, Int64, Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Resizes the tensor to be four dimensional with the specified size, the contents of the tensor after this are undetermined.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Resize4d (long size0, long size1, long size2, long size3);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size0</span></td>
        <td><p>The desired new size for the first dimension of the tensor.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size1</span></td>
        <td><p>The desired new size for the second dimension of the tensor.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size2</span></td>
        <td><p>The desired new size for the third dimension of the tensor.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size3</span></td>
        <td><p>The desired new size for the fourth dimension of the tensor.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Resize5d_" data-uid="TorchSharp.DoubleTensor.Resize5d*"></a>
  <h4 id="TorchSharp_DoubleTensor_Resize5d_System_Int64_System_Int64_System_Int64_System_Int64_System_Int64_" data-uid="TorchSharp.DoubleTensor.Resize5d(System.Int64,System.Int64,System.Int64,System.Int64,System.Int64)">Resize5d(Int64, Int64, Int64, Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Resizes the tensor to be five dimensional with the specified size, the contents of the tensor after this are undetermined.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Resize5d (long size0, long size1, long size2, long size3, long size4);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size0</span></td>
        <td><p>The desired new size for the first dimension of the tensor.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size1</span></td>
        <td><p>The desired new size for the second dimension of the tensor.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size2</span></td>
        <td><p>The desired new size for the third dimension of the tensor.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size3</span></td>
        <td><p>The desired new size for the fourth dimension of the tensor.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size4</span></td>
        <td><p>The desired new size for the fifth dimension of the tensor.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_ResizeAs_" data-uid="TorchSharp.DoubleTensor.ResizeAs*"></a>
  <h4 id="TorchSharp_DoubleTensor_ResizeAs_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.ResizeAs(TorchSharp.DoubleTensor)">ResizeAs(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Resizes the tensor to match the dimensions of the specified src tensor, the contents of the tensor after this are undetermined.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void ResizeAs (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The source tensor whose shape will be mirrored by this tensor.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Round_" data-uid="TorchSharp.DoubleTensor.Round*"></a>
  <h4 id="TorchSharp_DoubleTensor_Round" data-uid="TorchSharp.DoubleTensor.Round">Round()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Round of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Round ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Round_" data-uid="TorchSharp.DoubleTensor.Round*"></a>
  <h4 id="TorchSharp_DoubleTensor_Round_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Round(TorchSharp.DoubleTensor)">Round(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Round of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Round (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_RShift_" data-uid="TorchSharp.DoubleTensor.RShift*"></a>
  <h4 id="TorchSharp_DoubleTensor_RShift_System_Double_" data-uid="TorchSharp.DoubleTensor.RShift(System.Double)">RShift(Double)</h4>
  <div class="markdown level1 summary"><p>Performs the RShift operation on each element of the tensor with the
              <see paramref="value"></see> and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor RShift (double value);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_DoubleTensor_RShift_System_Double__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>If you want to avoid the allocation of a new tensor, you can use the 
              alternative method <span class="xref">PytorchSharp.RShift(PytorchSharp.DoubleTensor, Double, PytorchSharp.Double)</span>.</p>
</div>
  
  
  <a id="TorchSharp_DoubleTensor_RShift_" data-uid="TorchSharp.DoubleTensor.RShift*"></a>
  <h4 id="TorchSharp_DoubleTensor_RShift_TorchSharp_DoubleTensor_System_Double_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.RShift(TorchSharp.DoubleTensor,System.Double,TorchSharp.DoubleTensor)">RShift(DoubleTensor, Double, DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs the RShift operation on each element of the source with the
              provided scalar.   The result tensor specified as the last parameters
              is resized to match the source.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public static void RShift (TorchSharp.DoubleTensor source, double value, TorchSharp.DoubleTensor result);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>Source tensor on which the operation will take place.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>The scalar value that the operation uses.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">result</span></td>
        <td><p>The tensor where the result will be placed</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_DoubleTensor_RShift_TorchSharp_DoubleTensor_System_Double_TorchSharp_DoubleTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>For each element in the <see paramref="source"></see> performs the RShift operation
               with <see paramref="value"></see>.   The result is stored in the <see paramref="result"></see>
               tensor.</p>
</div>
  
  
  <a id="TorchSharp_DoubleTensor_Rsqrt_" data-uid="TorchSharp.DoubleTensor.Rsqrt*"></a>
  <h4 id="TorchSharp_DoubleTensor_Rsqrt_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Rsqrt(TorchSharp.DoubleTensor)">Rsqrt(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Rsqrt of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Rsqrt (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Rsqrt_" data-uid="TorchSharp.DoubleTensor.Rsqrt*"></a>
  <h4 id="TorchSharp_DoubleTensor_Rsqrt" data-uid="TorchSharp.DoubleTensor.Rsqrt">Rsqrt()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Rsqrt of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Rsqrt ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Scatter_" data-uid="TorchSharp.DoubleTensor.Scatter*"></a>
  <h4 id="TorchSharp_DoubleTensor_Scatter_System_Int32_TorchSharp_LongTensor_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Scatter(System.Int32,TorchSharp.LongTensor,TorchSharp.DoubleTensor)">Scatter(Int32, LongTensor, DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Scatter</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Scatter (int dim, TorchSharp.LongTensor index, TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dim</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a></td>
        <td><span class="parametername">index</span></td>
        <td><p>Indices of entries to copy.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_ScatterAdd_" data-uid="TorchSharp.DoubleTensor.ScatterAdd*"></a>
  <h4 id="TorchSharp_DoubleTensor_ScatterAdd_System_Int32_TorchSharp_LongTensor_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.ScatterAdd(System.Int32,TorchSharp.LongTensor,TorchSharp.DoubleTensor)">ScatterAdd(Int32, LongTensor, DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>ScatterAdd</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void ScatterAdd (int dim, TorchSharp.LongTensor index, TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dim</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a></td>
        <td><span class="parametername">index</span></td>
        <td><p>Indices of entries to copy.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_ScatterFill_" data-uid="TorchSharp.DoubleTensor.ScatterFill*"></a>
  <h4 id="TorchSharp_DoubleTensor_ScatterFill_System_Int32_TorchSharp_LongTensor_System_Double_" data-uid="TorchSharp.DoubleTensor.ScatterFill(System.Int32,TorchSharp.LongTensor,System.Double)">ScatterFill(Int32, LongTensor, Double)</h4>
  <div class="markdown level1 summary"><p>ScatterAdd</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void ScatterFill (int dim, TorchSharp.LongTensor index, double value);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dim</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a></td>
        <td><span class="parametername">index</span></td>
        <td><p>Indices of entries to copy.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Select_" data-uid="TorchSharp.DoubleTensor.Select*"></a>
  <h4 id="TorchSharp_DoubleTensor_Select_System_Int32_System_Int64_" data-uid="TorchSharp.DoubleTensor.Select(System.Int32,System.Int64)">Select(Int32, Int64)</h4>
  <div class="markdown level1 summary"><p>Returns a new Tensor which is a tensor slice at the given index in the dimension dim.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Select (int dim, long slideIndex);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dim</span></td>
        <td><p>Dimension to select</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">slideIndex</span></td>
        <td><p>Beginning of the tensor slice</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_DoubleTensor_Select_System_Int32_System_Int64__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>The returned tensor has one less dimension: the dimension dim is removed. As a result, it is not possible to select() on a 1D tensor.</p>
</div>
  
  
  <a id="TorchSharp_DoubleTensor_Set_" data-uid="TorchSharp.DoubleTensor.Set*"></a>
  <h4 id="TorchSharp_DoubleTensor_Set_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Set(TorchSharp.DoubleTensor)">Set(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>The tensor will use the same storage as the provided source, so any changes to that tensor are visible on this one.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Set (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The source tensor which contains the data..</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Sigmoid_" data-uid="TorchSharp.DoubleTensor.Sigmoid*"></a>
  <h4 id="TorchSharp_DoubleTensor_Sigmoid" data-uid="TorchSharp.DoubleTensor.Sigmoid">Sigmoid()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Sigmoid of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Sigmoid ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Sigmoid_" data-uid="TorchSharp.DoubleTensor.Sigmoid*"></a>
  <h4 id="TorchSharp_DoubleTensor_Sigmoid_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Sigmoid(TorchSharp.DoubleTensor)">Sigmoid(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Sigmoid of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Sigmoid (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Sign_" data-uid="TorchSharp.DoubleTensor.Sign*"></a>
  <h4 id="TorchSharp_DoubleTensor_Sign" data-uid="TorchSharp.DoubleTensor.Sign">Sign()</h4>
  <div class="markdown level1 summary"><p>Computes the sign of the tensor.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Sign ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Sin_" data-uid="TorchSharp.DoubleTensor.Sin*"></a>
  <h4 id="TorchSharp_DoubleTensor_Sin" data-uid="TorchSharp.DoubleTensor.Sin">Sin()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Sin of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Sin ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Sin_" data-uid="TorchSharp.DoubleTensor.Sin*"></a>
  <h4 id="TorchSharp_DoubleTensor_Sin_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Sin(TorchSharp.DoubleTensor)">Sin(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Sin of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Sin (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Sinh_" data-uid="TorchSharp.DoubleTensor.Sinh*"></a>
  <h4 id="TorchSharp_DoubleTensor_Sinh" data-uid="TorchSharp.DoubleTensor.Sinh">Sinh()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Sinh of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Sinh ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Sinh_" data-uid="TorchSharp.DoubleTensor.Sinh*"></a>
  <h4 id="TorchSharp_DoubleTensor_Sinh_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Sinh(TorchSharp.DoubleTensor)">Sinh(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Sinh of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Sinh (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Sort_" data-uid="TorchSharp.DoubleTensor.Sort*"></a>
  <h4 id="TorchSharp_DoubleTensor_Sort_System_Int32_System_Boolean_" data-uid="TorchSharp.DoubleTensor.Sort(System.Int32,System.Boolean)">Sort(Int32, Boolean)</h4>
  <div class="markdown level1 summary"><p>Sorts the elements of the tensor along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public Tuple&lt;TorchSharp.DoubleTensor,TorchSharp.LongTensor&gt; Sort (int dimension, bool descending);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to sort along.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">descending</span></td>
        <td><p>0 if ascending, 1 if descending.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Tuple</span>&lt;<a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a>,<a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a>&gt;</td>
        <td><p>A tuple containing the values and indices of the sorted elements.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Sqrt_" data-uid="TorchSharp.DoubleTensor.Sqrt*"></a>
  <h4 id="TorchSharp_DoubleTensor_Sqrt_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Sqrt(TorchSharp.DoubleTensor)">Sqrt(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Sqrt of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Sqrt (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Sqrt_" data-uid="TorchSharp.DoubleTensor.Sqrt*"></a>
  <h4 id="TorchSharp_DoubleTensor_Sqrt" data-uid="TorchSharp.DoubleTensor.Sqrt">Sqrt()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Sqrt of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Sqrt ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Squeeze_" data-uid="TorchSharp.DoubleTensor.Squeeze*"></a>
  <h4 id="TorchSharp_DoubleTensor_Squeeze" data-uid="TorchSharp.DoubleTensor.Squeeze">Squeeze()</h4>
  <div class="markdown level1 summary"><p>Squeeze the tensor, i.e. remove all 1-sized dimensions.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Squeeze ();</code></pre>
  </div>
  
  
  <a id="TorchSharp_DoubleTensor_Squeeze1d_" data-uid="TorchSharp.DoubleTensor.Squeeze1d*"></a>
  <h4 id="TorchSharp_DoubleTensor_Squeeze1d_TorchSharp_DoubleTensor_System_Int32_" data-uid="TorchSharp.DoubleTensor.Squeeze1d(TorchSharp.DoubleTensor,System.Int32)">Squeeze1d(DoubleTensor, Int32)</h4>
  <div class="markdown level1 summary"><p>Squeeze the tensor, by removing the specified dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Squeeze1d (TorchSharp.DoubleTensor src, int dimension);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The source tensor which contains the data.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to remove.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Std_" data-uid="TorchSharp.DoubleTensor.Std*"></a>
  <h4 id="TorchSharp_DoubleTensor_Std_System_Int32_System_Boolean_System_Boolean_" data-uid="TorchSharp.DoubleTensor.Std(System.Int32,System.Boolean,System.Boolean)">Std(Int32, Boolean, Boolean)</h4>
  <div class="markdown level1 summary"><p>Compute the standard deviation of all tensor elements along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Std (int dimension, bool biased, bool keepdim);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to process along.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">biased</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">keepdim</span></td>
        <td><p>true if the reduction dimension should be kept, false otherwise.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_StdAll_" data-uid="TorchSharp.DoubleTensor.StdAll*"></a>
  <h4 id="TorchSharp_DoubleTensor_StdAll_System_Boolean_" data-uid="TorchSharp.DoubleTensor.StdAll(System.Boolean)">StdAll(Boolean)</h4>
  <div class="markdown level1 summary"><p>Compute the standard deviation of all tensor elements.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public double StdAll (bool biased);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">biased</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Sub_" data-uid="TorchSharp.DoubleTensor.Sub*"></a>
  <h4 id="TorchSharp_DoubleTensor_Sub_System_Double_" data-uid="TorchSharp.DoubleTensor.Sub(System.Double)">Sub(Double)</h4>
  <div class="markdown level1 summary"><p>Performs the Sub operation on each element of the tensor with the
              <see paramref="value"></see> and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Sub (double value);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_DoubleTensor_Sub_System_Double__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>If you want to avoid the allocation of a new tensor, you can use the 
              alternative method <span class="xref">PytorchSharp.Sub(PytorchSharp.DoubleTensor, Double, PytorchSharp.Double)</span>.</p>
</div>
  
  
  <a id="TorchSharp_DoubleTensor_Sub_" data-uid="TorchSharp.DoubleTensor.Sub*"></a>
  <h4 id="TorchSharp_DoubleTensor_Sub_TorchSharp_DoubleTensor_System_Double_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Sub(TorchSharp.DoubleTensor,System.Double,TorchSharp.DoubleTensor)">Sub(DoubleTensor, Double, DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Performs the Sub operation on each element of the source with the
              provided scalar.   The result tensor specified as the last parameters
              is resized to match the source.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public static void Sub (TorchSharp.DoubleTensor source, double value, TorchSharp.DoubleTensor result);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>Source tensor on which the operation will take place.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>The scalar value that the operation uses.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">result</span></td>
        <td><p>The tensor where the result will be placed</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_DoubleTensor_Sub_TorchSharp_DoubleTensor_System_Double_TorchSharp_DoubleTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>For each element in the <see paramref="source"></see> performs the Sub operation
               with <see paramref="value"></see>.   The result is stored in the <see paramref="result"></see>
               tensor.</p>
</div>
  
  
  <a id="TorchSharp_DoubleTensor_SubScaled_" data-uid="TorchSharp.DoubleTensor.SubScaled*"></a>
  <h4 id="TorchSharp_DoubleTensor_SubScaled_System_Double_System_Double_" data-uid="TorchSharp.DoubleTensor.SubScaled(System.Double,System.Double)">SubScaled(Double, Double)</h4>
  <div class="markdown level1 summary"><p>Performs an SubScaled of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor SubScaled (double value1, double value2);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value1</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">value2</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Sum_" data-uid="TorchSharp.DoubleTensor.Sum*"></a>
  <h4 id="TorchSharp_DoubleTensor_Sum_System_Int32_System_Boolean_" data-uid="TorchSharp.DoubleTensor.Sum(System.Int32,System.Boolean)">Sum(Int32, Boolean)</h4>
  <div class="markdown level1 summary"><p>Computes the sum of all the elements of the tensor along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Sum (int dimension, bool keepdim);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to process along.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">keepdim</span></td>
        <td><p>true if the reduction dimension should be kept, false otherwise.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_SumAll_" data-uid="TorchSharp.DoubleTensor.SumAll*"></a>
  <h4 id="TorchSharp_DoubleTensor_SumAll" data-uid="TorchSharp.DoubleTensor.SumAll">SumAll()</h4>
  <div class="markdown level1 summary"><p>Returns the sum of the elements in the tensor.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public double SumAll ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><p>The sum of the tensor.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Take_" data-uid="TorchSharp.DoubleTensor.Take*"></a>
  <h4 id="TorchSharp_DoubleTensor_Take_TorchSharp_DoubleTensor_TorchSharp_LongTensor_" data-uid="TorchSharp.DoubleTensor.Take(TorchSharp.DoubleTensor,TorchSharp.LongTensor)">Take(DoubleTensor, LongTensor)</h4>
  <div class="markdown level1 summary"><p>Take</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Take (TorchSharp.DoubleTensor src, TorchSharp.LongTensor index);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a></td>
        <td><span class="parametername">index</span></td>
        <td><p>Indices of entries to copy.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Tan_" data-uid="TorchSharp.DoubleTensor.Tan*"></a>
  <h4 id="TorchSharp_DoubleTensor_Tan" data-uid="TorchSharp.DoubleTensor.Tan">Tan()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Tan of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Tan ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Tan_" data-uid="TorchSharp.DoubleTensor.Tan*"></a>
  <h4 id="TorchSharp_DoubleTensor_Tan_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Tan(TorchSharp.DoubleTensor)">Tan(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Tan of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Tan (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Tanh_" data-uid="TorchSharp.DoubleTensor.Tanh*"></a>
  <h4 id="TorchSharp_DoubleTensor_Tanh" data-uid="TorchSharp.DoubleTensor.Tanh">Tanh()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Tanh of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Tanh ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Tanh_" data-uid="TorchSharp.DoubleTensor.Tanh*"></a>
  <h4 id="TorchSharp_DoubleTensor_Tanh_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Tanh(TorchSharp.DoubleTensor)">Tanh(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Tanh of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Tanh (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_TopK_" data-uid="TorchSharp.DoubleTensor.TopK*"></a>
  <h4 id="TorchSharp_DoubleTensor_TopK_System_Int64_System_Int32_System_Int32_System_Boolean_" data-uid="TorchSharp.DoubleTensor.TopK(System.Int64,System.Int32,System.Int32,System.Boolean)">TopK(Int64, Int32, Int32, Boolean)</h4>
  <div class="markdown level1 summary"><p>Finds the top k of all the elements of the tensor along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public Tuple&lt;TorchSharp.DoubleTensor,TorchSharp.LongTensor&gt; TopK (long k, int dim, int dir, bool sorted);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">k</span></td>
        <td><p>The number of elements to fetch.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dim</span></td>
        <td><p>The dimension along which to sort and find k elements.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dir</span></td>
        <td><p>0 if ascending, 1 if descending.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">sorted</span></td>
        <td><p>1 if the result should be sorted, 0 if they should keep their original order.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Tuple</span>&lt;<a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a>,<a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a>&gt;</td>
        <td><p>A tuple containing the values and indices of the top &#39;k&#39; elements.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_ToString_" data-uid="TorchSharp.DoubleTensor.ToString*"></a>
  <h4 id="TorchSharp_DoubleTensor_ToString" data-uid="TorchSharp.DoubleTensor.ToString">ToString()</h4>
  <div class="markdown level1 summary"><p>Get a string representation of the tensor.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public override string ToString ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.String</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_TPow_" data-uid="TorchSharp.DoubleTensor.TPow*"></a>
  <h4 id="TorchSharp_DoubleTensor_TPow_System_Double_" data-uid="TorchSharp.DoubleTensor.TPow(System.Double)">TPow(Double)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with <see paramref="x"></see> raised to the power of <see paramref="this"></see>.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor TPow (double x);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">x</span></td>
        <td><p>The base.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Trace_" data-uid="TorchSharp.DoubleTensor.Trace*"></a>
  <h4 id="TorchSharp_DoubleTensor_Trace" data-uid="TorchSharp.DoubleTensor.Trace">Trace()</h4>
  <div class="markdown level1 summary"><p>Computes the trace of the tensor.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public double Trace ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Transpose_" data-uid="TorchSharp.DoubleTensor.Transpose*"></a>
  <h4 id="TorchSharp_DoubleTensor_Transpose_System_Int32_System_Int32_" data-uid="TorchSharp.DoubleTensor.Transpose(System.Int32,System.Int32)">Transpose(Int32, Int32)</h4>
  <div class="markdown level1 summary"><p>Returns a tensor where dimensions dim1 and dim2 have been swapped.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Transpose (int dim1, int dim2);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dim1</span></td>
        <td><p>First dimension</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dim2</span></td>
        <td><p>Second dimension</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Trigamma_" data-uid="TorchSharp.DoubleTensor.Trigamma*"></a>
  <h4 id="TorchSharp_DoubleTensor_Trigamma" data-uid="TorchSharp.DoubleTensor.Trigamma">Trigamma()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Trigamma of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Trigamma ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Trigamma_" data-uid="TorchSharp.DoubleTensor.Trigamma*"></a>
  <h4 id="TorchSharp_DoubleTensor_Trigamma_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Trigamma(TorchSharp.DoubleTensor)">Trigamma(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Trigamma of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Trigamma (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_TriL_" data-uid="TorchSharp.DoubleTensor.TriL*"></a>
  <h4 id="TorchSharp_DoubleTensor_TriL_System_Int64_" data-uid="TorchSharp.DoubleTensor.TriL(System.Int64)">TriL(Int64)</h4>
  <div class="markdown level1 summary"><p>Lower triangle.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor TriL (long k);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">k</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_TriU_" data-uid="TorchSharp.DoubleTensor.TriU*"></a>
  <h4 id="TorchSharp_DoubleTensor_TriU_System_Int64_" data-uid="TorchSharp.DoubleTensor.TriU(System.Int64)">TriU(Int64)</h4>
  <div class="markdown level1 summary"><p>Upper triangle.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor TriU (long k);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">k</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Trunc_" data-uid="TorchSharp.DoubleTensor.Trunc*"></a>
  <h4 id="TorchSharp_DoubleTensor_Trunc" data-uid="TorchSharp.DoubleTensor.Trunc">Trunc()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Trunc of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Trunc ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Trunc_" data-uid="TorchSharp.DoubleTensor.Trunc*"></a>
  <h4 id="TorchSharp_DoubleTensor_Trunc_TorchSharp_DoubleTensor_" data-uid="TorchSharp.DoubleTensor.Trunc(TorchSharp.DoubleTensor)">Trunc(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Trunc of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Trunc (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Unfold_" data-uid="TorchSharp.DoubleTensor.Unfold*"></a>
  <h4 id="TorchSharp_DoubleTensor_Unfold_System_Int32_System_Int64_System_Int64_" data-uid="TorchSharp.DoubleTensor.Unfold(System.Int32,System.Int64,System.Int64)">Unfold(Int32, Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Returns a tensor which contains all slices of size size in the dimension dim. Step between two slices is given by step.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Unfold (int dim, long size, long step);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dim</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">step</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Uniform_" data-uid="TorchSharp.DoubleTensor.Uniform*"></a>
  <h4 id="TorchSharp_DoubleTensor_Uniform_TorchSharp_RandomGenerator_System_Double_System_Double_" data-uid="TorchSharp.DoubleTensor.Uniform(TorchSharp.RandomGenerator,System.Double,System.Double)">Uniform(RandomGenerator, Double, Double)</h4>
  <div class="markdown level1 summary"><p>Fills the tensor with values according to a Bernoulli distribution.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Uniform (TorchSharp.RandomGenerator source, double min, double max);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.RandomGenerator.html">RandomGenerator</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>The random generator source</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">min</span></td>
        <td><p>The lower bound for the random number range.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">max</span></td>
        <td><p>The upper bound for the random number range.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Unsqueeze1d_" data-uid="TorchSharp.DoubleTensor.Unsqueeze1d*"></a>
  <h4 id="TorchSharp_DoubleTensor_Unsqueeze1d_TorchSharp_DoubleTensor_System_Int32_" data-uid="TorchSharp.DoubleTensor.Unsqueeze1d(TorchSharp.DoubleTensor,System.Int32)">Unsqueeze1d(DoubleTensor, Int32)</h4>
  <div class="markdown level1 summary"><p>Unsqueeze the tensor, by inserting the specified dimension of size 1.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Unsqueeze1d (TorchSharp.DoubleTensor src, int dimension);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The source tensor which contains the data.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to insert.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_Var_" data-uid="TorchSharp.DoubleTensor.Var*"></a>
  <h4 id="TorchSharp_DoubleTensor_Var_System_Int32_System_Boolean_System_Boolean_" data-uid="TorchSharp.DoubleTensor.Var(System.Int32,System.Boolean,System.Boolean)">Var(Int32, Boolean, Boolean)</h4>
  <div class="markdown level1 summary"><p>Compute the variance of all tensor elements along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor Var (int dimension, bool biased, bool keepdim);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to process along.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">biased</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">keepdim</span></td>
        <td><p>true if the reduction dimension should be kept, false otherwise.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_VarAll_" data-uid="TorchSharp.DoubleTensor.VarAll*"></a>
  <h4 id="TorchSharp_DoubleTensor_VarAll_System_Boolean_" data-uid="TorchSharp.DoubleTensor.VarAll(System.Boolean)">VarAll(Boolean)</h4>
  <div class="markdown level1 summary"><p>Compute the variance of all tensor elements.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public double VarAll (bool biased);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">biased</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_DoubleTensor_ZeroFill_" data-uid="TorchSharp.DoubleTensor.ZeroFill*"></a>
  <h4 id="TorchSharp_DoubleTensor_ZeroFill" data-uid="TorchSharp.DoubleTensor.ZeroFill">ZeroFill()</h4>
  <div class="markdown level1 summary"><p>Fills the tensor with zeros</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void ZeroFill ();</code></pre>
  </div>
  
  
  <a id="TorchSharp_DoubleTensor_ZerosLike_" data-uid="TorchSharp.DoubleTensor.ZerosLike*"></a>
  <h4 id="TorchSharp_DoubleTensor_ZerosLike" data-uid="TorchSharp.DoubleTensor.ZerosLike">ZerosLike()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the ZerosLike of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.DoubleTensor ZerosLike ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
</article>
          </div>
          
          <div class="hidden-sm col-md-2" role="complementary">
            <div class="sideaffix">
              <div class="contribution">
                <ul class="nav">
                </ul>
              </div>
              <nav class="bs-docs-sidebar hidden-print hidden-xs hidden-sm affix" id="affix">
              <!-- <p><a class="back-to-top" href="#top">Back to top</a><p> -->
              </nav>
            </div>
          </div>
        </div>
      </div>
      
      <footer>
        <div class="grad-bottom"></div>
        <div class="footer">
          <div class="container">
            <span class="pull-right">
              <a href="#top">Back to top</a>
            </span>
            
            <span>Copyright © 2015-2017 Microsoft<br>Generated by <strong>DocFX</strong></span>
          </div>
        </div>
      </footer>
    </div>
    
    <script type="text/javascript" src="../../styles/docfx.vendor.js"></script>
    <script type="text/javascript" src="../../styles/docfx.js"></script>
    <script type="text/javascript" src="../../styles/main.js"></script>
  </body>
</html>
